Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* linux/kernel/fork.c

2

* linux/kernel/fork.c

3

*

3

*

4

5

*/

5

*/

6

7

/*

7

/*

8

* 'fork.c' contains the help-routines for the 'fork' system call

8

* 'fork.c' contains the help-routines for the 'fork' system call

9

* (see also entry.S and others).

9

* (see also entry.S and others).

10

* Fork is rather simple, once you get the hang of it, but the memory

10

* Fork is rather simple, once you get the hang of it, but the memory

11

* management can be a bitch. See 'mm/memory.c': 'copy_page_range()'

11

* management can be a bitch. See 'mm/memory.c': 'copy_page_range()'

12

*/

12

*/

13

14

#include <linux/slab.h>

14

#include <linux/slab.h>

15

#include <linux/init.h>

15

#include <linux/init.h>

16

#include <linux/unistd.h>

16

#include <linux/unistd.h>

17

#include <linux/module.h>

17

#include <linux/module.h>

18

#include <linux/vmalloc.h>

18

#include <linux/vmalloc.h>

19

#include <linux/completion.h>

19

#include <linux/completion.h>

20

#include <linux/mnt_namespace.h>

20

#include <linux/mnt_namespace.h>

21

#include <linux/personality.h>

21

#include <linux/personality.h>

22

#include <linux/mempolicy.h>

22

#include <linux/mempolicy.h>

23

#include <linux/sem.h>

23

#include <linux/sem.h>

24

#include <linux/file.h>

24

#include <linux/file.h>

25

#include <linux/key.h>

25

#include <linux/key.h>

26

#include <linux/binfmts.h>

26

#include <linux/binfmts.h>

27

#include <linux/mman.h>

27

#include <linux/mman.h>

28

#include <linux/fs.h>

28

#include <linux/fs.h>

29

#include <linux/nsproxy.h>

29

#include <linux/nsproxy.h>

30

#include <linux/capability.h>

30

#include <linux/capability.h>

31

#include <linux/cpu.h>

31

#include <linux/cpu.h>

32

#include <linux/cgroup.h>

32

#include <linux/cgroup.h>

33

#include <linux/security.h>

33

#include <linux/security.h>

34

#include <linux/swap.h>

34

#include <linux/swap.h>

35

#include <linux/syscalls.h>

35

#include <linux/syscalls.h>

36

#include <linux/jiffies.h>

36

#include <linux/jiffies.h>

37

#include <linux/futex.h>

37

#include <linux/futex.h>

38

#include <linux/task_io_accounting_ops.h>

38

#include <linux/task_io_accounting_ops.h>

39

#include <linux/rcupdate.h>

39

#include <linux/rcupdate.h>

40

#include <linux/ptrace.h>

40

#include <linux/ptrace.h>

41

#include <linux/mount.h>

41

#include <linux/mount.h>

42

#include <linux/audit.h>

42

#include <linux/audit.h>

43

#include <linux/memcontrol.h>

43

#include <linux/memcontrol.h>

44

#include <linux/profile.h>

44

#include <linux/profile.h>

45

#include <linux/rmap.h>

45

#include <linux/rmap.h>

46

#include <linux/acct.h>

46

#include <linux/acct.h>

47

#include <linux/tsacct_kern.h>

47

#include <linux/tsacct_kern.h>

48

#include <linux/cn_proc.h>

48

#include <linux/cn_proc.h>

49

#include <linux/freezer.h>

49

#include <linux/freezer.h>

50

#include <linux/delayacct.h>

50

#include <linux/delayacct.h>

51

#include <linux/taskstats_kern.h>

51

#include <linux/taskstats_kern.h>

52

#include <linux/random.h>

52

#include <linux/random.h>

53

#include <linux/tty.h>

53

#include <linux/tty.h>

54

#include <linux/proc_fs.h>

54

#include <linux/proc_fs.h>

55

#include <linux/blkdev.h>

55

#include <linux/blkdev.h>

56

57

#include <asm/pgtable.h>

57

#include <asm/pgtable.h>

58

#include <asm/pgalloc.h>

58

#include <asm/pgalloc.h>

59

#include <asm/uaccess.h>

59

#include <asm/uaccess.h>

60

#include <asm/mmu_context.h>

60

#include <asm/mmu_context.h>

61

#include <asm/cacheflush.h>

61

#include <asm/cacheflush.h>

62

#include <asm/tlbflush.h>

62

#include <asm/tlbflush.h>

63

64

/*

64

/*

65

* Protected counters by write_lock_irq(&tasklist_lock)

65

* Protected counters by write_lock_irq(&tasklist_lock)

66

*/

66

*/

67

unsigned long total_forks; /* Handle normal Linux uptimes. */

67

unsigned long total_forks; /* Handle normal Linux uptimes. */

68

int nr_threads; /* The idle threads do not count.. */

68

int nr_threads; /* The idle threads do not count.. */

69

70

int max_threads; /* tunable limit on nr_threads */

70

int max_threads; /* tunable limit on nr_threads */

71

72

DEFINE_PER_CPU(unsigned long, process_counts) = 0;

72

DEFINE_PER_CPU(unsigned long, process_counts) = 0;

73

74

__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */

74

__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */

75

76

int nr_processes(void)

76

int nr_processes(void)

77

{

77

{

78

int cpu;

78

int cpu;

79

int total = 0;

79

int total = 0;

80

81

for_each_online_cpu(cpu)

81

for_each_online_cpu(cpu)

82

total += per_cpu(process_counts, cpu);

82

total += per_cpu(process_counts, cpu);

83

84

return total;

84

return total;

85

}

85

}

86

87

#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR

87

#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR

88

# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)

88

# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)

89

# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))

89

# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))

90

static struct kmem_cache *task_struct_cachep;

90

static struct kmem_cache *task_struct_cachep;

91

#endif

91

#endif

92

93

/* SLAB cache for signal_struct structures (tsk->signal) */

93

/* SLAB cache for signal_struct structures (tsk->signal) */

94

static struct kmem_cache *signal_cachep;

94

static struct kmem_cache *signal_cachep;

95

96

/* SLAB cache for sighand_struct structures (tsk->sighand) */

96

/* SLAB cache for sighand_struct structures (tsk->sighand) */

97

struct kmem_cache *sighand_cachep;

97

struct kmem_cache *sighand_cachep;

98

99

/* SLAB cache for files_struct structures (tsk->files) */

99

/* SLAB cache for files_struct structures (tsk->files) */

100

struct kmem_cache *files_cachep;

100

struct kmem_cache *files_cachep;

101

102

/* SLAB cache for fs_struct structures (tsk->fs) */

102

/* SLAB cache for fs_struct structures (tsk->fs) */

103

struct kmem_cache *fs_cachep;

103

struct kmem_cache *fs_cachep;

104

105

/* SLAB cache for vm_area_struct structures */

105

/* SLAB cache for vm_area_struct structures */

106

struct kmem_cache *vm_area_cachep;

106

struct kmem_cache *vm_area_cachep;

107

108

/* SLAB cache for mm_struct structures (tsk->mm) */

108

/* SLAB cache for mm_struct structures (tsk->mm) */

109

static struct kmem_cache *mm_cachep;

109

static struct kmem_cache *mm_cachep;

110

111

void free_task(struct task_struct *tsk)

111

void free_task(struct task_struct *tsk)

112

{

112

{

113

prop_local_destroy_single(&tsk->dirties);

113

prop_local_destroy_single(&tsk->dirties);

114

free_thread_info(tsk->stack);

114

free_thread_info(tsk->stack);

115

rt_mutex_debug_task_free(tsk);

115

rt_mutex_debug_task_free(tsk);

116

free_task_struct(tsk);

116

free_task_struct(tsk);

117

}

117

}

118

EXPORT_SYMBOL(free_task);

118

EXPORT_SYMBOL(free_task);

119

120

void __put_task_struct(struct task_struct *tsk)

120

void __put_task_struct(struct task_struct *tsk)

121

{

121

{

122

WARN_ON(!tsk->exit_state);

122

WARN_ON(!tsk->exit_state);

123

WARN_ON(atomic_read(&tsk->usage));

123

WARN_ON(atomic_read(&tsk->usage));

124

WARN_ON(tsk == current);

124

WARN_ON(tsk == current);

125

126

security_task_free(tsk);

126

security_task_free(tsk);

127

free_uid(tsk->user);

127

free_uid(tsk->user);

128

put_group_info(tsk->group_info);

128

put_group_info(tsk->group_info);

129

delayacct_tsk_free(tsk);

129

delayacct_tsk_free(tsk);

130

131

if (!profile_handoff_task(tsk))

131

if (!profile_handoff_task(tsk))

132

free_task(tsk);

132

free_task(tsk);

133

}

133

}

134

135

void __attribute__((weak)) arch_task_cache_init(void)

135

/*

136

{

136

* macro override instead of weak attribute alias, to workaround

137

}

137

* gcc 4.1.0 and 4.1.1 bugs with weak attribute and empty functions.

138

*/

139

#ifndef arch_task_cache_init

140

#define arch_task_cache_init()

141

#endif

138

142

139

void __init fork_init(unsigned long mempages)

143

void __init fork_init(unsigned long mempages)

140

{

144

{

141

#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR

145

#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR

142

#ifndef ARCH_MIN_TASKALIGN

146

#ifndef ARCH_MIN_TASKALIGN

143

#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES

147

#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES

144

#endif

148

#endif

145

/* create a slab on which task_structs can be allocated */

149

/* create a slab on which task_structs can be allocated */

146

task_struct_cachep =

150

task_struct_cachep =

147

kmem_cache_create("task_struct", sizeof(struct task_struct),

151

kmem_cache_create("task_struct", sizeof(struct task_struct),

148

ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);

152

ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);

149

#endif

153

#endif

150

154

151

/* do the arch specific task caches init */

155

/* do the arch specific task caches init */

152

arch_task_cache_init();

156

arch_task_cache_init();

153

157

154

/*

158

/*

155

* The default maximum number of threads is set to a safe

159

* The default maximum number of threads is set to a safe

156

* value: the thread structures can take up at most half

160

* value: the thread structures can take up at most half

157

* of memory.

161

* of memory.

158

*/

162

*/

159

max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

163

max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

160

164

161

/*

165

/*

162

* we need to allow at least 20 threads to boot a system

166

* we need to allow at least 20 threads to boot a system

163

*/

167

*/

164

if(max_threads < 20)

168

if(max_threads < 20)

165

max_threads = 20;

169

max_threads = 20;

166

170

167

init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;

171

init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;

168

init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;

172

init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;

169

init_task.signal->rlim[RLIMIT_SIGPENDING] =

173

init_task.signal->rlim[RLIMIT_SIGPENDING] =

170

init_task.signal->rlim[RLIMIT_NPROC];

174

init_task.signal->rlim[RLIMIT_NPROC];

171

}

175

}

172

176

173

int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst,

177

int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst,

174

struct task_struct *src)

178

struct task_struct *src)

175

{

179

{

176

*dst = *src;

180

*dst = *src;

177

return 0;

181

return 0;

178

}

182

}

179

183

180

static struct task_struct *dup_task_struct(struct task_struct *orig)

184

static struct task_struct *dup_task_struct(struct task_struct *orig)

181

{

185

{

182

struct task_struct *tsk;

186

struct task_struct *tsk;

183

struct thread_info *ti;

187

struct thread_info *ti;

184

int err;

188

int err;

185

189

186

prepare_to_copy(orig);

190

prepare_to_copy(orig);

187

191

188

tsk = alloc_task_struct();

192

tsk = alloc_task_struct();

189

if (!tsk)

193

if (!tsk)

190

return NULL;

194

return NULL;

191

195

192

ti = alloc_thread_info(tsk);

196

ti = alloc_thread_info(tsk);

193

if (!ti) {

197

if (!ti) {

194

free_task_struct(tsk);

198

free_task_struct(tsk);

195

return NULL;

199

return NULL;

196

}

200

}

197

201

198

err = arch_dup_task_struct(tsk, orig);

202

err = arch_dup_task_struct(tsk, orig);

199

if (err)

203

if (err)

200

goto out;

204

goto out;

201

205

202

tsk->stack = ti;

206

tsk->stack = ti;

203

207

204

err = prop_local_init_single(&tsk->dirties);

208

err = prop_local_init_single(&tsk->dirties);

205

if (err)

209

if (err)

206

goto out;

210

goto out;

207

211

208

setup_thread_stack(tsk, orig);

212

setup_thread_stack(tsk, orig);

209

213

210

#ifdef CONFIG_CC_STACKPROTECTOR

214

#ifdef CONFIG_CC_STACKPROTECTOR

211

tsk->stack_canary = get_random_int();

215

tsk->stack_canary = get_random_int();

212

#endif

216

#endif

213

217

214

/* One for us, one for whoever does the "release_task()" (usually parent) */

218

/* One for us, one for whoever does the "release_task()" (usually parent) */

215

atomic_set(&tsk->usage,2);

219

atomic_set(&tsk->usage,2);

216

atomic_set(&tsk->fs_excl, 0);

220

atomic_set(&tsk->fs_excl, 0);

217

#ifdef CONFIG_BLK_DEV_IO_TRACE

221

#ifdef CONFIG_BLK_DEV_IO_TRACE

218

tsk->btrace_seq = 0;

222

tsk->btrace_seq = 0;

219

#endif

223

#endif

220

tsk->splice_pipe = NULL;

224

tsk->splice_pipe = NULL;

221

return tsk;

225

return tsk;

222

226

223

out:

227

out:

224

free_thread_info(ti);

228

free_thread_info(ti);

225

free_task_struct(tsk);

229

free_task_struct(tsk);

226

return NULL;

230

return NULL;

227

}

231

}

228

232

229

#ifdef CONFIG_MMU

233

#ifdef CONFIG_MMU

230

static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)

234

static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)

231

{

235

{

232

struct vm_area_struct *mpnt, *tmp, **pprev;

236

struct vm_area_struct *mpnt, *tmp, **pprev;

233

struct rb_node **rb_link, *rb_parent;

237

struct rb_node **rb_link, *rb_parent;

234

int retval;

238

int retval;

235

unsigned long charge;

239

unsigned long charge;

236

struct mempolicy *pol;

240

struct mempolicy *pol;

237

241

238

down_write(&oldmm->mmap_sem);

242

down_write(&oldmm->mmap_sem);

239

flush_cache_dup_mm(oldmm);

243

flush_cache_dup_mm(oldmm);

240

/*

244

/*

241

* Not linked in yet - no deadlock potential:

245

* Not linked in yet - no deadlock potential:

242

*/

246

*/

243

down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);

247

down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);

244

248

245

mm->locked_vm = 0;

249

mm->locked_vm = 0;

246

mm->mmap = NULL;

250

mm->mmap = NULL;

247

mm->mmap_cache = NULL;

251

mm->mmap_cache = NULL;

248

mm->free_area_cache = oldmm->mmap_base;

252

mm->free_area_cache = oldmm->mmap_base;

249

mm->cached_hole_size = ~0UL;

253

mm->cached_hole_size = ~0UL;

250

mm->map_count = 0;

254

mm->map_count = 0;

251

cpus_clear(mm->cpu_vm_mask);

255

cpus_clear(mm->cpu_vm_mask);

252

mm->mm_rb = RB_ROOT;

256

mm->mm_rb = RB_ROOT;

253

rb_link = &mm->mm_rb.rb_node;

257

rb_link = &mm->mm_rb.rb_node;

254

rb_parent = NULL;

258

rb_parent = NULL;

255

pprev = &mm->mmap;

259

pprev = &mm->mmap;

256

260

257

for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {

261

for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {

258

struct file *file;

262

struct file *file;

259

263

260

if (mpnt->vm_flags & VM_DONTCOPY) {

264

if (mpnt->vm_flags & VM_DONTCOPY) {

261

long pages = vma_pages(mpnt);

265

long pages = vma_pages(mpnt);

262

mm->total_vm -= pages;

266

mm->total_vm -= pages;

263

vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,

267

vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,

264

-pages);

268

-pages);

265

continue;

269

continue;

266

}

270

}

267

charge = 0;

271

charge = 0;

268

if (mpnt->vm_flags & VM_ACCOUNT) {

272

if (mpnt->vm_flags & VM_ACCOUNT) {

269

unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;

273

unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;

270

if (security_vm_enough_memory(len))

274

if (security_vm_enough_memory(len))

271

goto fail_nomem;

275

goto fail_nomem;

272

charge = len;

276

charge = len;

273

}

277

}

274

tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);

278

tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);

275

if (!tmp)

279

if (!tmp)

276

goto fail_nomem;

280

goto fail_nomem;

277

*tmp = *mpnt;

281

*tmp = *mpnt;

278

pol = mpol_copy(vma_policy(mpnt));

282

pol = mpol_copy(vma_policy(mpnt));

279

retval = PTR_ERR(pol);

283

retval = PTR_ERR(pol);

280

if (IS_ERR(pol))

284

if (IS_ERR(pol))

281

goto fail_nomem_policy;

285

goto fail_nomem_policy;

282

vma_set_policy(tmp, pol);

286

vma_set_policy(tmp, pol);

283

tmp->vm_flags &= ~VM_LOCKED;

287

tmp->vm_flags &= ~VM_LOCKED;

284

tmp->vm_mm = mm;

288

tmp->vm_mm = mm;

285

tmp->vm_next = NULL;

289

tmp->vm_next = NULL;

286

anon_vma_link(tmp);

290

anon_vma_link(tmp);

287

file = tmp->vm_file;

291

file = tmp->vm_file;

288

if (file) {

292

if (file) {

289

struct inode *inode = file->f_path.dentry->d_inode;

293

struct inode *inode = file->f_path.dentry->d_inode;

290

get_file(file);

294

get_file(file);

291

if (tmp->vm_flags & VM_DENYWRITE)

295

if (tmp->vm_flags & VM_DENYWRITE)

292

atomic_dec(&inode->i_writecount);

296

atomic_dec(&inode->i_writecount);

293

297

294

/* insert tmp into the share list, just after mpnt */

298

/* insert tmp into the share list, just after mpnt */

295

spin_lock(&file->f_mapping->i_mmap_lock);

299

spin_lock(&file->f_mapping->i_mmap_lock);

296

tmp->vm_truncate_count = mpnt->vm_truncate_count;

300

tmp->vm_truncate_count = mpnt->vm_truncate_count;

297

flush_dcache_mmap_lock(file->f_mapping);

301

flush_dcache_mmap_lock(file->f_mapping);

298

vma_prio_tree_add(tmp, mpnt);

302

vma_prio_tree_add(tmp, mpnt);

299

flush_dcache_mmap_unlock(file->f_mapping);

303

flush_dcache_mmap_unlock(file->f_mapping);

300

spin_unlock(&file->f_mapping->i_mmap_lock);

304

spin_unlock(&file->f_mapping->i_mmap_lock);

301

}

305

}

302

306

303

/*

307

/*

304

* Link in the new vma and copy the page table entries.

308

* Link in the new vma and copy the page table entries.

305

*/

309

*/

306

*pprev = tmp;

310

*pprev = tmp;

307

pprev = &tmp->vm_next;

311

pprev = &tmp->vm_next;

308

312

309

__vma_link_rb(mm, tmp, rb_link, rb_parent);

313

__vma_link_rb(mm, tmp, rb_link, rb_parent);

310

rb_link = &tmp->vm_rb.rb_right;

314

rb_link = &tmp->vm_rb.rb_right;

311

rb_parent = &tmp->vm_rb;

315

rb_parent = &tmp->vm_rb;

312

316

313

mm->map_count++;

317

mm->map_count++;

314

retval = copy_page_range(mm, oldmm, mpnt);

318

retval = copy_page_range(mm, oldmm, mpnt);

315

319

316

if (tmp->vm_ops && tmp->vm_ops->open)

320

if (tmp->vm_ops && tmp->vm_ops->open)

317

tmp->vm_ops->open(tmp);

321

tmp->vm_ops->open(tmp);

318

322

319

if (retval)

323

if (retval)

320

goto out;

324

goto out;

321

}

325

}

322

/* a new mm has just been created */

326

/* a new mm has just been created */

323

arch_dup_mmap(oldmm, mm);

327

arch_dup_mmap(oldmm, mm);

324

retval = 0;

328

retval = 0;

325

out:

329

out:

326

up_write(&mm->mmap_sem);

330

up_write(&mm->mmap_sem);

327

flush_tlb_mm(oldmm);

331

flush_tlb_mm(oldmm);

328

up_write(&oldmm->mmap_sem);

332

up_write(&oldmm->mmap_sem);

329

return retval;

333

return retval;

330

fail_nomem_policy:

334

fail_nomem_policy:

331

kmem_cache_free(vm_area_cachep, tmp);

335

kmem_cache_free(vm_area_cachep, tmp);

332

fail_nomem:

336

fail_nomem:

333

retval = -ENOMEM;

337

retval = -ENOMEM;

334

vm_unacct_memory(charge);

338

vm_unacct_memory(charge);

335

goto out;

339

goto out;

336

}

340

}

337

341

338

static inline int mm_alloc_pgd(struct mm_struct * mm)

342

static inline int mm_alloc_pgd(struct mm_struct * mm)

339

{

343

{

340

mm->pgd = pgd_alloc(mm);

344

mm->pgd = pgd_alloc(mm);

341

if (unlikely(!mm->pgd))

345

if (unlikely(!mm->pgd))

342

return -ENOMEM;

346

return -ENOMEM;

343

return 0;

347

return 0;

344

}

348

}

345

349

346

static inline void mm_free_pgd(struct mm_struct * mm)

350

static inline void mm_free_pgd(struct mm_struct * mm)

347

{

351

{

348

pgd_free(mm, mm->pgd);

352

pgd_free(mm, mm->pgd);

349

}

353

}

350

#else

354

#else

351

#define dup_mmap(mm, oldmm) (0)

355

#define dup_mmap(mm, oldmm) (0)

352

#define mm_alloc_pgd(mm) (0)

356

#define mm_alloc_pgd(mm) (0)

353

#define mm_free_pgd(mm)

357

#define mm_free_pgd(mm)

354

#endif /* CONFIG_MMU */

358

#endif /* CONFIG_MMU */

355

359

356

__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);

360

__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);

357

361

358

#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))

362

#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))

359

#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))

363

#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))

360

364

361

#include <linux/init_task.h>

365

#include <linux/init_task.h>

362

366

363

static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)

367

static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)

364

{

368

{

365

atomic_set(&mm->mm_users, 1);

369

atomic_set(&mm->mm_users, 1);

366

atomic_set(&mm->mm_count, 1);

370

atomic_set(&mm->mm_count, 1);

367

init_rwsem(&mm->mmap_sem);

371

init_rwsem(&mm->mmap_sem);

368

INIT_LIST_HEAD(&mm->mmlist);

372

INIT_LIST_HEAD(&mm->mmlist);

369

mm->flags = (current->mm) ? current->mm->flags

373

mm->flags = (current->mm) ? current->mm->flags

370

: MMF_DUMP_FILTER_DEFAULT;

374

: MMF_DUMP_FILTER_DEFAULT;

371

mm->core_waiters = 0;

375

mm->core_waiters = 0;

372

mm->nr_ptes = 0;

376

mm->nr_ptes = 0;

373

set_mm_counter(mm, file_rss, 0);

377

set_mm_counter(mm, file_rss, 0);

374

set_mm_counter(mm, anon_rss, 0);

378

set_mm_counter(mm, anon_rss, 0);

375

spin_lock_init(&mm->page_table_lock);

379

spin_lock_init(&mm->page_table_lock);

376

rwlock_init(&mm->ioctx_list_lock);

380

rwlock_init(&mm->ioctx_list_lock);

377

mm->ioctx_list = NULL;

381

mm->ioctx_list = NULL;

378

mm->free_area_cache = TASK_UNMAPPED_BASE;

382

mm->free_area_cache = TASK_UNMAPPED_BASE;

379

mm->cached_hole_size = ~0UL;

383

mm->cached_hole_size = ~0UL;

380

mm_init_cgroup(mm, p);

384

mm_init_cgroup(mm, p);

381

385

382

if (likely(!mm_alloc_pgd(mm))) {

386

if (likely(!mm_alloc_pgd(mm))) {

383

mm->def_flags = 0;

387

mm->def_flags = 0;

384

return mm;

388

return mm;

385

}

389

}

386

390

387

mm_free_cgroup(mm);

391

mm_free_cgroup(mm);

388

free_mm(mm);

392

free_mm(mm);

389

return NULL;

393

return NULL;

390

}

394

}

391

395

392

/*

396

/*

393

* Allocate and initialize an mm_struct.

397

* Allocate and initialize an mm_struct.

394

*/

398

*/

395

struct mm_struct * mm_alloc(void)

399

struct mm_struct * mm_alloc(void)

396

{

400

{

397

struct mm_struct * mm;

401

struct mm_struct * mm;

398

402

399

mm = allocate_mm();

403

mm = allocate_mm();

400

if (mm) {

404

if (mm) {

401

memset(mm, 0, sizeof(*mm));

405

memset(mm, 0, sizeof(*mm));

402

mm = mm_init(mm, current);

406

mm = mm_init(mm, current);

403

}

407

}

404

return mm;

408

return mm;

405

}

409

}

406

410

407

/*

411

/*

408

* Called when the last reference to the mm

412

* Called when the last reference to the mm

409

* is dropped: either by a lazy thread or by

413

* is dropped: either by a lazy thread or by

410

* mmput. Free the page directory and the mm.

414

* mmput. Free the page directory and the mm.

411

*/

415

*/

412

void __mmdrop(struct mm_struct *mm)

416

void __mmdrop(struct mm_struct *mm)

413

{

417

{

414

BUG_ON(mm == &init_mm);

418

BUG_ON(mm == &init_mm);

415

mm_free_pgd(mm);

419

mm_free_pgd(mm);

416

destroy_context(mm);

420

destroy_context(mm);

417

free_mm(mm);

421

free_mm(mm);

418

}

422

}

419

EXPORT_SYMBOL_GPL(__mmdrop);

423

EXPORT_SYMBOL_GPL(__mmdrop);

420

424

421

/*

425

/*

422

* Decrement the use count and release all resources for an mm.

426

* Decrement the use count and release all resources for an mm.

423

*/

427

*/

424

void mmput(struct mm_struct *mm)

428

void mmput(struct mm_struct *mm)

425

{

429

{

426

might_sleep();

430

might_sleep();

427

431

428

if (atomic_dec_and_test(&mm->mm_users)) {

432

if (atomic_dec_and_test(&mm->mm_users)) {

429

exit_aio(mm);

433

exit_aio(mm);

430

exit_mmap(mm);

434

exit_mmap(mm);

431

if (!list_empty(&mm->mmlist)) {

435

if (!list_empty(&mm->mmlist)) {

432

spin_lock(&mmlist_lock);

436

spin_lock(&mmlist_lock);

433

list_del(&mm->mmlist);

437

list_del(&mm->mmlist);

434

spin_unlock(&mmlist_lock);

438

spin_unlock(&mmlist_lock);

435

}

439

}

436

put_swap_token(mm);

440

put_swap_token(mm);

437

mm_free_cgroup(mm);

441

mm_free_cgroup(mm);

438

mmdrop(mm);

442

mmdrop(mm);

439

}

443

}

440

}

444

}

441

EXPORT_SYMBOL_GPL(mmput);

445

EXPORT_SYMBOL_GPL(mmput);

442

446

443

/**

447

/**

444

* get_task_mm - acquire a reference to the task's mm

448

* get_task_mm - acquire a reference to the task's mm

445

*

449

*

446

* Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning

450

* Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning

447

* this kernel workthread has transiently adopted a user mm with use_mm,

451

* this kernel workthread has transiently adopted a user mm with use_mm,

448

* to do its AIO) is not set and if so returns a reference to it, after

452

* to do its AIO) is not set and if so returns a reference to it, after

449

* bumping up the use count. User must release the mm via mmput()

453

* bumping up the use count. User must release the mm via mmput()

450

* after use. Typically used by /proc and ptrace.

454

* after use. Typically used by /proc and ptrace.

451

*/

455

*/

452

struct mm_struct *get_task_mm(struct task_struct *task)

456

struct mm_struct *get_task_mm(struct task_struct *task)

453

{

457

{

454

struct mm_struct *mm;

458

struct mm_struct *mm;

455

459

456

task_lock(task);

460

task_lock(task);

457

mm = task->mm;

461

mm = task->mm;

458

if (mm) {

462

if (mm) {

459

if (task->flags & PF_BORROWED_MM)

463

if (task->flags & PF_BORROWED_MM)

460

mm = NULL;

464

mm = NULL;

461

else

465

else

462

atomic_inc(&mm->mm_users);

466

atomic_inc(&mm->mm_users);

463

}

467

}

464

task_unlock(task);

468

task_unlock(task);

465

return mm;

469

return mm;

466

}

470

}

467

EXPORT_SYMBOL_GPL(get_task_mm);

471

EXPORT_SYMBOL_GPL(get_task_mm);

468

472

469

/* Please note the differences between mmput and mm_release.

473

/* Please note the differences between mmput and mm_release.

470

* mmput is called whenever we stop holding onto a mm_struct,

474

* mmput is called whenever we stop holding onto a mm_struct,

471

* error success whatever.

475

* error success whatever.

472

*

476

*

473

* mm_release is called after a mm_struct has been removed

477

* mm_release is called after a mm_struct has been removed

474

* from the current process.

478

* from the current process.

475

*

479

*

476

* This difference is important for error handling, when we

480

* This difference is important for error handling, when we

477

* only half set up a mm_struct for a new process and need to restore

481

* only half set up a mm_struct for a new process and need to restore

478

* the old one. Because we mmput the new mm_struct before

482

* the old one. Because we mmput the new mm_struct before

479

* restoring the old one. . .

483

* restoring the old one. . .

480

* Eric Biederman 10 January 1998

484

* Eric Biederman 10 January 1998

481

*/

485

*/

482

void mm_release(struct task_struct *tsk, struct mm_struct *mm)

486

void mm_release(struct task_struct *tsk, struct mm_struct *mm)

483

{

487

{

484

struct completion *vfork_done = tsk->vfork_done;

488

struct completion *vfork_done = tsk->vfork_done;

485

489

486

/* Get rid of any cached register state */

490

/* Get rid of any cached register state */

487

deactivate_mm(tsk, mm);

491

deactivate_mm(tsk, mm);

488

492

489

/* notify parent sleeping on vfork() */

493

/* notify parent sleeping on vfork() */

490

if (vfork_done) {

494

if (vfork_done) {

491

tsk->vfork_done = NULL;

495

tsk->vfork_done = NULL;

492

complete(vfork_done);

496

complete(vfork_done);

493

}

497

}

494

498

495

/*

499

/*

496

* If we're exiting normally, clear a user-space tid field if

500

* If we're exiting normally, clear a user-space tid field if

497

* requested. We leave this alone when dying by signal, to leave

501

* requested. We leave this alone when dying by signal, to leave

498

* the value intact in a core dump, and to save the unnecessary

502

* the value intact in a core dump, and to save the unnecessary

499

* trouble otherwise. Userland only wants this done for a sys_exit.

503

* trouble otherwise. Userland only wants this done for a sys_exit.

500

*/

504

*/

501

if (tsk->clear_child_tid

505

if (tsk->clear_child_tid

502

&& !(tsk->flags & PF_SIGNALED)

506

&& !(tsk->flags & PF_SIGNALED)

503

&& atomic_read(&mm->mm_users) > 1) {

507

&& atomic_read(&mm->mm_users) > 1) {

504

u32 __user * tidptr = tsk->clear_child_tid;

508

u32 __user * tidptr = tsk->clear_child_tid;

505

tsk->clear_child_tid = NULL;

509

tsk->clear_child_tid = NULL;

506

510

507

/*

511

/*

508

* We don't check the error code - if userspace has

512

* We don't check the error code - if userspace has

509

* not set up a proper pointer then tough luck.

513

* not set up a proper pointer then tough luck.

510

*/

514

*/

511

put_user(0, tidptr);

515

put_user(0, tidptr);

512

sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);

516

sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);

513

}

517

}

514

}

518

}

515

519

516

/*

520

/*

517

* Allocate a new mm structure and copy contents from the

521

* Allocate a new mm structure and copy contents from the

518

* mm structure of the passed in task structure.

522

* mm structure of the passed in task structure.

519

*/

523

*/

520

static struct mm_struct *dup_mm(struct task_struct *tsk)

524

static struct mm_struct *dup_mm(struct task_struct *tsk)

521

{

525

{

522

struct mm_struct *mm, *oldmm = current->mm;

526

struct mm_struct *mm, *oldmm = current->mm;

523

int err;

527

int err;

524

528

525

if (!oldmm)

529

if (!oldmm)

526

return NULL;

530

return NULL;

527

531

528

mm = allocate_mm();

532

mm = allocate_mm();

529

if (!mm)

533

if (!mm)

530

goto fail_nomem;

534

goto fail_nomem;

531

535

532

memcpy(mm, oldmm, sizeof(*mm));

536

memcpy(mm, oldmm, sizeof(*mm));

533

537

534

/* Initializing for Swap token stuff */

538

/* Initializing for Swap token stuff */

535

mm->token_priority = 0;

539

mm->token_priority = 0;

536

mm->last_interval = 0;

540

mm->last_interval = 0;

537

541

538

if (!mm_init(mm, tsk))

542

if (!mm_init(mm, tsk))

539

goto fail_nomem;

543

goto fail_nomem;

540

544

541

if (init_new_context(tsk, mm))

545

if (init_new_context(tsk, mm))

542

goto fail_nocontext;

546

goto fail_nocontext;

543

547

544

err = dup_mmap(mm, oldmm);

548

err = dup_mmap(mm, oldmm);

545

if (err)

549

if (err)

546

goto free_pt;

550

goto free_pt;

547

551

548

mm->hiwater_rss = get_mm_rss(mm);

552

mm->hiwater_rss = get_mm_rss(mm);

549

mm->hiwater_vm = mm->total_vm;

553

mm->hiwater_vm = mm->total_vm;

550

554

551

return mm;

555

return mm;

552

556

553

free_pt:

557

free_pt:

554

mmput(mm);

558

mmput(mm);

555

559

556

fail_nomem:

560

fail_nomem:

557

return NULL;

561

return NULL;

558

562

559

fail_nocontext:

563

fail_nocontext:

560

/*

564

/*

561

* If init_new_context() failed, we cannot use mmput() to free the mm

565

* If init_new_context() failed, we cannot use mmput() to free the mm

562

* because it calls destroy_context()

566

* because it calls destroy_context()

563

*/

567

*/

564

mm_free_pgd(mm);

568

mm_free_pgd(mm);

565

free_mm(mm);

569

free_mm(mm);

566

return NULL;

570

return NULL;

567

}

571

}

568

572

569

static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)

573

static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)

570

{

574

{

571

struct mm_struct * mm, *oldmm;

575

struct mm_struct * mm, *oldmm;

572

int retval;

576

int retval;

573

577

574

tsk->min_flt = tsk->maj_flt = 0;

578

tsk->min_flt = tsk->maj_flt = 0;

575

tsk->nvcsw = tsk->nivcsw = 0;

579

tsk->nvcsw = tsk->nivcsw = 0;

576

580

577

tsk->mm = NULL;

581

tsk->mm = NULL;

578

tsk->active_mm = NULL;

582

tsk->active_mm = NULL;

579

583

580

/*

584

/*

581

* Are we cloning a kernel thread?

585

* Are we cloning a kernel thread?

582

*

586

*

583

* We need to steal a active VM for that..

587

* We need to steal a active VM for that..

584

*/

588

*/

585

oldmm = current->mm;

589

oldmm = current->mm;

586

if (!oldmm)

590

if (!oldmm)

587

return 0;

591

return 0;

588

592

589

if (clone_flags & CLONE_VM) {

593

if (clone_flags & CLONE_VM) {

590

atomic_inc(&oldmm->mm_users);

594

atomic_inc(&oldmm->mm_users);

591

mm = oldmm;

595

mm = oldmm;

592

goto good_mm;

596

goto good_mm;

593

}

597

}

594

598

595

retval = -ENOMEM;

599

retval = -ENOMEM;

596

mm = dup_mm(tsk);

600

mm = dup_mm(tsk);

597

if (!mm)

601

if (!mm)

598

goto fail_nomem;

602

goto fail_nomem;

599

603

600

good_mm:

604

good_mm:

601

/* Initializing for Swap token stuff */

605

/* Initializing for Swap token stuff */

602

mm->token_priority = 0;

606

mm->token_priority = 0;

603

mm->last_interval = 0;

607

mm->last_interval = 0;

604

608

605

tsk->mm = mm;

609

tsk->mm = mm;

606

tsk->active_mm = mm;

610

tsk->active_mm = mm;

607

return 0;

611

return 0;

608

612

609

fail_nomem:

613

fail_nomem:

610

return retval;

614

return retval;

611

}

615

}

612

616

613

static struct fs_struct *__copy_fs_struct(struct fs_struct *old)

617

static struct fs_struct *__copy_fs_struct(struct fs_struct *old)

614

{

618

{

615

struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);

619

struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);

616

/* We don't need to lock fs - think why ;-) */

620

/* We don't need to lock fs - think why ;-) */

617

if (fs) {

621

if (fs) {

618

atomic_set(&fs->count, 1);

622

atomic_set(&fs->count, 1);

619

rwlock_init(&fs->lock);

623

rwlock_init(&fs->lock);

620

fs->umask = old->umask;

624

fs->umask = old->umask;

621

read_lock(&old->lock);

625

read_lock(&old->lock);

622

fs->root = old->root;

626

fs->root = old->root;

623

path_get(&old->root);

627

path_get(&old->root);

624

fs->pwd = old->pwd;

628

fs->pwd = old->pwd;

625

path_get(&old->pwd);

629

path_get(&old->pwd);

626

if (old->altroot.dentry) {

630

if (old->altroot.dentry) {

627

fs->altroot = old->altroot;

631

fs->altroot = old->altroot;

628

path_get(&old->altroot);

632

path_get(&old->altroot);

629

} else {

633

} else {

630

fs->altroot.mnt = NULL;

634

fs->altroot.mnt = NULL;

631

fs->altroot.dentry = NULL;

635

fs->altroot.dentry = NULL;

632

}

636

}

633

read_unlock(&old->lock);

637

read_unlock(&old->lock);

634

}

638

}

635

return fs;

639

return fs;

636

}

640

}

637

641

638

struct fs_struct *copy_fs_struct(struct fs_struct *old)

642

struct fs_struct *copy_fs_struct(struct fs_struct *old)

639

{

643

{

640

return __copy_fs_struct(old);

644

return __copy_fs_struct(old);

641

}

645

}

642

646

643

EXPORT_SYMBOL_GPL(copy_fs_struct);

647

EXPORT_SYMBOL_GPL(copy_fs_struct);

644

648

645

static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)

649

static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)

646

{

650

{

647

if (clone_flags & CLONE_FS) {

651

if (clone_flags & CLONE_FS) {

648

atomic_inc(&current->fs->count);

652

atomic_inc(&current->fs->count);

649

return 0;

653

return 0;

650

}

654

}

651

tsk->fs = __copy_fs_struct(current->fs);

655

tsk->fs = __copy_fs_struct(current->fs);

652

if (!tsk->fs)

656

if (!tsk->fs)

653

return -ENOMEM;

657

return -ENOMEM;

654

return 0;

658

return 0;

655

}

659

}

656

660

657

static int count_open_files(struct fdtable *fdt)

661

static int count_open_files(struct fdtable *fdt)

658

{

662

{

659

int size = fdt->max_fds;

663

int size = fdt->max_fds;

660

int i;

664

int i;

661

665

662

/* Find the last open fd */

666

/* Find the last open fd */

663

for (i = size/(8*sizeof(long)); i > 0; ) {

667

for (i = size/(8*sizeof(long)); i > 0; ) {

664

if (fdt->open_fds->fds_bits[--i])

668

if (fdt->open_fds->fds_bits[--i])

665

break;

669

break;

666

}

670

}

667

i = (i+1) * 8 * sizeof(long);

671

i = (i+1) * 8 * sizeof(long);

668

return i;

672

return i;

669

}

673

}

670

674

671

static struct files_struct *alloc_files(void)

675

static struct files_struct *alloc_files(void)

672

{

676

{

673

struct files_struct *newf;

677

struct files_struct *newf;

674

struct fdtable *fdt;

678

struct fdtable *fdt;

675

679

676

newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);

680

newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);

677

if (!newf)

681

if (!newf)

678

goto out;

682

goto out;

679

683

680

atomic_set(&newf->count, 1);

684

atomic_set(&newf->count, 1);

681

685

682

spin_lock_init(&newf->file_lock);

686

spin_lock_init(&newf->file_lock);

683

newf->next_fd = 0;

687

newf->next_fd = 0;

684

fdt = &newf->fdtab;

688

fdt = &newf->fdtab;

685

fdt->max_fds = NR_OPEN_DEFAULT;

689

fdt->max_fds = NR_OPEN_DEFAULT;

686

fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;

690

fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;

687

fdt->open_fds = (fd_set *)&newf->open_fds_init;

691

fdt->open_fds = (fd_set *)&newf->open_fds_init;

688

fdt->fd = &newf->fd_array[0];

692

fdt->fd = &newf->fd_array[0];

689

INIT_RCU_HEAD(&fdt->rcu);

693

INIT_RCU_HEAD(&fdt->rcu);

690

fdt->next = NULL;

694

fdt->next = NULL;

691

rcu_assign_pointer(newf->fdt, fdt);

695

rcu_assign_pointer(newf->fdt, fdt);

692

out:

696

out:

693

return newf;

697

return newf;

694

}

698

}

695

699

696

/*

700

/*

697

* Allocate a new files structure and copy contents from the

701

* Allocate a new files structure and copy contents from the

698

* passed in files structure.

702

* passed in files structure.

699

* errorp will be valid only when the returned files_struct is NULL.

703

* errorp will be valid only when the returned files_struct is NULL.

700

*/

704

*/

701

static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)

705

static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)

702

{

706

{

703

struct files_struct *newf;

707

struct files_struct *newf;

704

struct file **old_fds, **new_fds;

708

struct file **old_fds, **new_fds;

705

int open_files, size, i;

709

int open_files, size, i;

706

struct fdtable *old_fdt, *new_fdt;

710

struct fdtable *old_fdt, *new_fdt;

707

711

708

*errorp = -ENOMEM;

712

*errorp = -ENOMEM;

709

newf = alloc_files();

713

newf = alloc_files();

710

if (!newf)

714

if (!newf)

711

goto out;

715

goto out;

712

716

713

spin_lock(&oldf->file_lock);

717

spin_lock(&oldf->file_lock);

714

old_fdt = files_fdtable(oldf);

718

old_fdt = files_fdtable(oldf);

715

new_fdt = files_fdtable(newf);

719

new_fdt = files_fdtable(newf);

716

open_files = count_open_files(old_fdt);

720

open_files = count_open_files(old_fdt);

717

721

718

/*

722

/*

719

* Check whether we need to allocate a larger fd array and fd set.

723

* Check whether we need to allocate a larger fd array and fd set.

720

* Note: we're not a clone task, so the open count won't change.

724

* Note: we're not a clone task, so the open count won't change.

721

*/

725

*/

722

if (open_files > new_fdt->max_fds) {

726

if (open_files > new_fdt->max_fds) {

723

new_fdt->max_fds = 0;

727

new_fdt->max_fds = 0;

724

spin_unlock(&oldf->file_lock);

728

spin_unlock(&oldf->file_lock);

725

spin_lock(&newf->file_lock);

729

spin_lock(&newf->file_lock);

726

*errorp = expand_files(newf, open_files-1);

730

*errorp = expand_files(newf, open_files-1);

727

spin_unlock(&newf->file_lock);

731

spin_unlock(&newf->file_lock);

728

if (*errorp < 0)

732

if (*errorp < 0)

729

goto out_release;

733

goto out_release;

730

new_fdt = files_fdtable(newf);

734

new_fdt = files_fdtable(newf);

731

/*

735

/*

732

* Reacquire the oldf lock and a pointer to its fd table

736

* Reacquire the oldf lock and a pointer to its fd table

733

* who knows it may have a new bigger fd table. We need

737

* who knows it may have a new bigger fd table. We need

734

* the latest pointer.

738

* the latest pointer.

735

*/

739

*/

736

spin_lock(&oldf->file_lock);

740

spin_lock(&oldf->file_lock);

737

old_fdt = files_fdtable(oldf);

741

old_fdt = files_fdtable(oldf);

738

}

742

}

739

743

740

old_fds = old_fdt->fd;

744

old_fds = old_fdt->fd;

741

new_fds = new_fdt->fd;

745

new_fds = new_fdt->fd;

742

746

743

memcpy(new_fdt->open_fds->fds_bits,

747

memcpy(new_fdt->open_fds->fds_bits,

744

old_fdt->open_fds->fds_bits, open_files/8);

748

old_fdt->open_fds->fds_bits, open_files/8);

745

memcpy(new_fdt->close_on_exec->fds_bits,

749

memcpy(new_fdt->close_on_exec->fds_bits,

746

old_fdt->close_on_exec->fds_bits, open_files/8);

750

old_fdt->close_on_exec->fds_bits, open_files/8);

747

751

748

for (i = open_files; i != 0; i--) {

752

for (i = open_files; i != 0; i--) {

749

struct file *f = *old_fds++;

753

struct file *f = *old_fds++;

750

if (f) {

754

if (f) {

751

get_file(f);

755

get_file(f);

752

} else {

756

} else {

753

/*

757

/*

754

* The fd may be claimed in the fd bitmap but not yet

758

* The fd may be claimed in the fd bitmap but not yet

755

* instantiated in the files array if a sibling thread

759

* instantiated in the files array if a sibling thread

756

* is partway through open(). So make sure that this

760

* is partway through open(). So make sure that this

757

* fd is available to the new process.

761

* fd is available to the new process.

758

*/

762

*/

759

FD_CLR(open_files - i, new_fdt->open_fds);

763

FD_CLR(open_files - i, new_fdt->open_fds);

760

}

764

}

761

rcu_assign_pointer(*new_fds++, f);

765

rcu_assign_pointer(*new_fds++, f);

762

}

766

}

763

spin_unlock(&oldf->file_lock);

767

spin_unlock(&oldf->file_lock);

764

768

765

/* compute the remainder to be cleared */

769

/* compute the remainder to be cleared */

766

size = (new_fdt->max_fds - open_files) * sizeof(struct file *);

770

size = (new_fdt->max_fds - open_files) * sizeof(struct file *);

767

771

768

/* This is long word aligned thus could use a optimized version */

772

/* This is long word aligned thus could use a optimized version */

769

memset(new_fds, 0, size);

773

memset(new_fds, 0, size);

770

774

771

if (new_fdt->max_fds > open_files) {

775

if (new_fdt->max_fds > open_files) {

772

int left = (new_fdt->max_fds-open_files)/8;

776

int left = (new_fdt->max_fds-open_files)/8;

773

int start = open_files / (8 * sizeof(unsigned long));

777

int start = open_files / (8 * sizeof(unsigned long));

774

778

775

memset(&new_fdt->open_fds->fds_bits[start], 0, left);

779

memset(&new_fdt->open_fds->fds_bits[start], 0, left);

776

memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);

780

memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);

777

}

781

}

778

782

779

return newf;

783

return newf;

780

784

781

out_release:

785

out_release:

782

kmem_cache_free(files_cachep, newf);

786

kmem_cache_free(files_cachep, newf);

783

out:

787

out:

784

return NULL;

788

return NULL;

785

}

789

}

786

790

787

static int copy_files(unsigned long clone_flags, struct task_struct * tsk)

791

static int copy_files(unsigned long clone_flags, struct task_struct * tsk)

788

{

792

{

789

struct files_struct *oldf, *newf;

793

struct files_struct *oldf, *newf;

790

int error = 0;

794

int error = 0;

791

795

792

/*

796

/*

793

* A background process may not have any files ...

797

* A background process may not have any files ...

794

*/

798

*/

795

oldf = current->files;

799

oldf = current->files;

796

if (!oldf)

800

if (!oldf)

797

goto out;

801

goto out;

798

802

799

if (clone_flags & CLONE_FILES) {

803

if (clone_flags & CLONE_FILES) {

800

atomic_inc(&oldf->count);

804

atomic_inc(&oldf->count);

801

goto out;

805

goto out;

802

}

806

}

803

807

804

/*

808

/*

805

* Note: we may be using current for both targets (See exec.c)

809

* Note: we may be using current for both targets (See exec.c)

806

* This works because we cache current->files (old) as oldf. Don't

810

* This works because we cache current->files (old) as oldf. Don't

807

* break this.

811

* break this.

808

*/

812

*/

809

tsk->files = NULL;

813

tsk->files = NULL;

810

newf = dup_fd(oldf, &error);

814

newf = dup_fd(oldf, &error);

811

if (!newf)

815

if (!newf)

812

goto out;

816

goto out;

813

817

814

tsk->files = newf;

818

tsk->files = newf;

815

error = 0;

819

error = 0;

816

out:

820

out:

817

return error;

821

return error;

818

}

822

}

819

823

820

static int copy_io(unsigned long clone_flags, struct task_struct *tsk)

824

static int copy_io(unsigned long clone_flags, struct task_struct *tsk)

821

{

825

{

822

#ifdef CONFIG_BLOCK

826

#ifdef CONFIG_BLOCK

823

struct io_context *ioc = current->io_context;

827

struct io_context *ioc = current->io_context;

824

828

825

if (!ioc)

829

if (!ioc)

826

return 0;

830

return 0;

827

/*

831

/*

828

* Share io context with parent, if CLONE_IO is set

832

* Share io context with parent, if CLONE_IO is set

829

*/

833

*/

830

if (clone_flags & CLONE_IO) {

834

if (clone_flags & CLONE_IO) {

831

tsk->io_context = ioc_task_link(ioc);

835

tsk->io_context = ioc_task_link(ioc);

832

if (unlikely(!tsk->io_context))

836

if (unlikely(!tsk->io_context))

833

return -ENOMEM;

837

return -ENOMEM;

834

} else if (ioprio_valid(ioc->ioprio)) {

838

} else if (ioprio_valid(ioc->ioprio)) {

835

tsk->io_context = alloc_io_context(GFP_KERNEL, -1);

839

tsk->io_context = alloc_io_context(GFP_KERNEL, -1);

836

if (unlikely(!tsk->io_context))

840

if (unlikely(!tsk->io_context))

837

return -ENOMEM;

841

return -ENOMEM;

838

842

839

tsk->io_context->ioprio = ioc->ioprio;

843

tsk->io_context->ioprio = ioc->ioprio;

840

}

844

}

841

#endif

845

#endif

842

return 0;

846

return 0;

843

}

847

}

844

848

845

/*

849

/*

846

* Helper to unshare the files of the current task.

850

* Helper to unshare the files of the current task.

847

* We don't want to expose copy_files internals to

851

* We don't want to expose copy_files internals to

848

* the exec layer of the kernel.

852

* the exec layer of the kernel.

849

*/

853

*/

850

854

851

int unshare_files(void)

855

int unshare_files(void)

852

{

856

{

853

struct files_struct *files = current->files;

857

struct files_struct *files = current->files;

854

int rc;

858

int rc;

855

859

856

BUG_ON(!files);

860

BUG_ON(!files);

857

861

858

/* This can race but the race causes us to copy when we don't

862

/* This can race but the race causes us to copy when we don't

859

need to and drop the copy */

863

need to and drop the copy */

860

if(atomic_read(&files->count) == 1)

864

if(atomic_read(&files->count) == 1)

861

{

865

{

862

atomic_inc(&files->count);

866

atomic_inc(&files->count);

863

return 0;

867

return 0;

864

}

868

}

865

rc = copy_files(0, current);

869

rc = copy_files(0, current);

866

if(rc)

870

if(rc)

867

current->files = files;

871

current->files = files;

868

return rc;

872

return rc;

869

}

873

}

870

874

871

EXPORT_SYMBOL(unshare_files);

875

EXPORT_SYMBOL(unshare_files);

872

876

873

static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)

877

static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)

874

{

878

{

875

struct sighand_struct *sig;

879

struct sighand_struct *sig;

876

880

877

if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {

881

if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {

878

atomic_inc(&current->sighand->count);

882

atomic_inc(&current->sighand->count);

879

return 0;

883

return 0;

880

}

884

}

881

sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);

885

sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);

882

rcu_assign_pointer(tsk->sighand, sig);

886

rcu_assign_pointer(tsk->sighand, sig);

883

if (!sig)

887

if (!sig)

884

return -ENOMEM;

888

return -ENOMEM;

885

atomic_set(&sig->count, 1);

889

atomic_set(&sig->count, 1);

886

memcpy(sig->action, current->sighand->action, sizeof(sig->action));

890

memcpy(sig->action, current->sighand->action, sizeof(sig->action));

887

return 0;

891

return 0;

888

}

892

}

889

893

890

void __cleanup_sighand(struct sighand_struct *sighand)

894

void __cleanup_sighand(struct sighand_struct *sighand)

891

{

895

{

892

if (atomic_dec_and_test(&sighand->count))

896

if (atomic_dec_and_test(&sighand->count))

893

kmem_cache_free(sighand_cachep, sighand);

897

kmem_cache_free(sighand_cachep, sighand);

894

}

898

}

895

899

896

static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)

900

static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)

897

{

901

{

898

struct signal_struct *sig;

902

struct signal_struct *sig;

899

int ret;

903

int ret;

900

904

901

if (clone_flags & CLONE_THREAD) {

905

if (clone_flags & CLONE_THREAD) {

902

atomic_inc(&current->signal->count);

906

atomic_inc(&current->signal->count);

903

atomic_inc(&current->signal->live);

907

atomic_inc(&current->signal->live);

904

return 0;

908

return 0;

905

}

909

}

906

sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);

910

sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);

907

tsk->signal = sig;

911

tsk->signal = sig;

908

if (!sig)

912

if (!sig)

909

return -ENOMEM;

913

return -ENOMEM;

910

914

911

ret = copy_thread_group_keys(tsk);

915

ret = copy_thread_group_keys(tsk);

912

if (ret < 0) {

916

if (ret < 0) {

913

kmem_cache_free(signal_cachep, sig);

917

kmem_cache_free(signal_cachep, sig);

914

return ret;

918

return ret;

915

}

919

}

916

920

917

atomic_set(&sig->count, 1);

921

atomic_set(&sig->count, 1);

918

atomic_set(&sig->live, 1);

922

atomic_set(&sig->live, 1);

919

init_waitqueue_head(&sig->wait_chldexit);

923

init_waitqueue_head(&sig->wait_chldexit);

920

sig->flags = 0;

924

sig->flags = 0;

921

sig->group_exit_code = 0;

925

sig->group_exit_code = 0;

922

sig->group_exit_task = NULL;

926

sig->group_exit_task = NULL;

923

sig->group_stop_count = 0;

927

sig->group_stop_count = 0;

924

sig->curr_target = NULL;

928

sig->curr_target = NULL;

925

init_sigpending(&sig->shared_pending);

929

init_sigpending(&sig->shared_pending);

926

INIT_LIST_HEAD(&sig->posix_timers);

930

INIT_LIST_HEAD(&sig->posix_timers);

927

931

928

hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

932

hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

929

sig->it_real_incr.tv64 = 0;

933

sig->it_real_incr.tv64 = 0;

930

sig->real_timer.function = it_real_fn;

934

sig->real_timer.function = it_real_fn;

931

935

932

sig->it_virt_expires = cputime_zero;

936

sig->it_virt_expires = cputime_zero;

933

sig->it_virt_incr = cputime_zero;

937

sig->it_virt_incr = cputime_zero;

934

sig->it_prof_expires = cputime_zero;

938

sig->it_prof_expires = cputime_zero;

935

sig->it_prof_incr = cputime_zero;

939

sig->it_prof_incr = cputime_zero;

936

940

937

sig->leader = 0; /* session leadership doesn't inherit */

941

sig->leader = 0; /* session leadership doesn't inherit */

938

sig->tty_old_pgrp = NULL;

942

sig->tty_old_pgrp = NULL;

939

943

940

sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;

944

sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;

941

sig->gtime = cputime_zero;

945

sig->gtime = cputime_zero;

942

sig->cgtime = cputime_zero;

946

sig->cgtime = cputime_zero;

943

sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;

947

sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;

944

sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;

948

sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;

945

sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;

949

sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;

946

sig->sum_sched_runtime = 0;

950

sig->sum_sched_runtime = 0;

947

INIT_LIST_HEAD(&sig->cpu_timers[0]);

951

INIT_LIST_HEAD(&sig->cpu_timers[0]);

948

INIT_LIST_HEAD(&sig->cpu_timers[1]);

952

INIT_LIST_HEAD(&sig->cpu_timers[1]);

949

INIT_LIST_HEAD(&sig->cpu_timers[2]);

953

INIT_LIST_HEAD(&sig->cpu_timers[2]);

950

taskstats_tgid_init(sig);

954

taskstats_tgid_init(sig);

951

955

952

task_lock(current->group_leader);

956

task_lock(current->group_leader);

953

memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);

957

memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);

954

task_unlock(current->group_leader);

958

task_unlock(current->group_leader);

955

959

956

if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {

960

if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {

957

/*

961

/*

958

* New sole thread in the process gets an expiry time

962

* New sole thread in the process gets an expiry time

959

* of the whole CPU time limit.

963

* of the whole CPU time limit.

960

*/

964

*/

961

tsk->it_prof_expires =

965

tsk->it_prof_expires =

962

secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);

966

secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);

963

}

967

}

964

acct_init_pacct(&sig->pacct);

968

acct_init_pacct(&sig->pacct);

965

969

966

tty_audit_fork(sig);

970

tty_audit_fork(sig);

967

971

968

return 0;

972

return 0;

969

}

973

}

970

974

971

void __cleanup_signal(struct signal_struct *sig)

975

void __cleanup_signal(struct signal_struct *sig)

972

{

976

{

973

exit_thread_group_keys(sig);

977

exit_thread_group_keys(sig);

974

kmem_cache_free(signal_cachep, sig);

978

kmem_cache_free(signal_cachep, sig);

975

}

979

}

976

980

977

static void cleanup_signal(struct task_struct *tsk)

981

static void cleanup_signal(struct task_struct *tsk)

978

{

982

{

979

struct signal_struct *sig = tsk->signal;

983

struct signal_struct *sig = tsk->signal;

980

984

981

atomic_dec(&sig->live);

985

atomic_dec(&sig->live);

982

986

983

if (atomic_dec_and_test(&sig->count))

987

if (atomic_dec_and_test(&sig->count))

984

__cleanup_signal(sig);

988

__cleanup_signal(sig);

985

}

989

}

986

990

987

static void copy_flags(unsigned long clone_flags, struct task_struct *p)

991

static void copy_flags(unsigned long clone_flags, struct task_struct *p)

988

{

992

{

989

unsigned long new_flags = p->flags;

993

unsigned long new_flags = p->flags;

990

994

991

new_flags &= ~PF_SUPERPRIV;

995

new_flags &= ~PF_SUPERPRIV;

992

new_flags |= PF_FORKNOEXEC;

996

new_flags |= PF_FORKNOEXEC;

993

if (!(clone_flags & CLONE_PTRACE))

997

if (!(clone_flags & CLONE_PTRACE))

994

p->ptrace = 0;

998

p->ptrace = 0;

995

p->flags = new_flags;

999

p->flags = new_flags;

996

clear_freeze_flag(p);

1000

clear_freeze_flag(p);

997

}

1001

}

998

1002

999

asmlinkage long sys_set_tid_address(int __user *tidptr)

1003

asmlinkage long sys_set_tid_address(int __user *tidptr)

1000

{

1004

{

1001

current->clear_child_tid = tidptr;

1005

current->clear_child_tid = tidptr;

1002

1006

1003

return task_pid_vnr(current);

1007

return task_pid_vnr(current);

1004

}

1008

}

1005

1009

1006

static void rt_mutex_init_task(struct task_struct *p)

1010

static void rt_mutex_init_task(struct task_struct *p)

1007

{

1011

{

1008

spin_lock_init(&p->pi_lock);

1012

spin_lock_init(&p->pi_lock);

1009

#ifdef CONFIG_RT_MUTEXES

1013

#ifdef CONFIG_RT_MUTEXES

1010

plist_head_init(&p->pi_waiters, &p->pi_lock);

1014

plist_head_init(&p->pi_waiters, &p->pi_lock);

1011

p->pi_blocked_on = NULL;

1015

p->pi_blocked_on = NULL;

1012

#endif

1016

#endif

1013

}

1017

}

1014

1018

1015

/*

1019

/*

1016

* This creates a new process as a copy of the old one,

1020

* This creates a new process as a copy of the old one,

1017

* but does not actually start it yet.

1021

* but does not actually start it yet.

1018

*

1022

*

1019

* It copies the registers, and all the appropriate

1023

* It copies the registers, and all the appropriate

1020

* parts of the process environment (as per the clone

1024

* parts of the process environment (as per the clone

1021

* flags). The actual kick-off is left to the caller.

1025

* flags). The actual kick-off is left to the caller.

1022

*/

1026

*/

1023

static struct task_struct *copy_process(unsigned long clone_flags,

1027

static struct task_struct *copy_process(unsigned long clone_flags,

1024

unsigned long stack_start,

1028

unsigned long stack_start,

1025

struct pt_regs *regs,

1029

struct pt_regs *regs,

1026

unsigned long stack_size,

1030

unsigned long stack_size,

1027

int __user *child_tidptr,

1031

int __user *child_tidptr,

1028

struct pid *pid)

1032

struct pid *pid)

1029

{

1033

{

1030

int retval;

1034

int retval;

1031

struct task_struct *p;

1035

struct task_struct *p;

1032

int cgroup_callbacks_done = 0;

1036

int cgroup_callbacks_done = 0;

1033

1037

1034

if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))

1038

if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))

1035

return ERR_PTR(-EINVAL);

1039

return ERR_PTR(-EINVAL);

1036

1040

1037

/*

1041

/*

1038

* Thread groups must share signals as well, and detached threads

1042

* Thread groups must share signals as well, and detached threads

1039

* can only be started up within the thread group.

1043

* can only be started up within the thread group.

1040

*/

1044

*/

1041

if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))

1045

if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))

1042

return ERR_PTR(-EINVAL);

1046

return ERR_PTR(-EINVAL);

1043

1047

1044

/*

1048

/*

1045

* Shared signal handlers imply shared VM. By way of the above,

1049

* Shared signal handlers imply shared VM. By way of the above,

1046

* thread groups also imply shared VM. Blocking this case allows

1050

* thread groups also imply shared VM. Blocking this case allows

1047

* for various simplifications in other code.

1051

* for various simplifications in other code.

1048

*/

1052

*/

1049

if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))

1053

if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))

1050

return ERR_PTR(-EINVAL);

1054

return ERR_PTR(-EINVAL);

1051

1055

1052

retval = security_task_create(clone_flags);

1056

retval = security_task_create(clone_flags);

1053

if (retval)

1057

if (retval)

1054

goto fork_out;

1058

goto fork_out;

1055

1059

1056

retval = -ENOMEM;

1060

retval = -ENOMEM;

1057

p = dup_task_struct(current);

1061

p = dup_task_struct(current);

1058

if (!p)

1062

if (!p)

1059

goto fork_out;

1063

goto fork_out;

1060

1064

1061

rt_mutex_init_task(p);

1065

rt_mutex_init_task(p);

1062

1066

1063

#ifdef CONFIG_TRACE_IRQFLAGS

1067

#ifdef CONFIG_TRACE_IRQFLAGS

1064

DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);

1068

DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);

1065

DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);

1069

DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);

1066

#endif

1070

#endif

1067

retval = -EAGAIN;

1071

retval = -EAGAIN;

1068

if (atomic_read(&p->user->processes) >=

1072

if (atomic_read(&p->user->processes) >=

1069

p->signal->rlim[RLIMIT_NPROC].rlim_cur) {

1073

p->signal->rlim[RLIMIT_NPROC].rlim_cur) {

1070

if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&

1074

if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&

1071

p->user != current->nsproxy->user_ns->root_user)

1075

p->user != current->nsproxy->user_ns->root_user)

1072

goto bad_fork_free;

1076

goto bad_fork_free;

1073

}

1077

}

1074

1078

1075

atomic_inc(&p->user->__count);

1079

atomic_inc(&p->user->__count);

1076

atomic_inc(&p->user->processes);

1080

atomic_inc(&p->user->processes);

1077

get_group_info(p->group_info);

1081

get_group_info(p->group_info);

1078

1082

1079

/*

1083

/*

1080

* If multiple threads are within copy_process(), then this check

1084

* If multiple threads are within copy_process(), then this check

1081

* triggers too late. This doesn't hurt, the check is only there

1085

* triggers too late. This doesn't hurt, the check is only there

1082

* to stop root fork bombs.

1086

* to stop root fork bombs.

1083

*/

1087

*/

1084

if (nr_threads >= max_threads)

1088

if (nr_threads >= max_threads)

1085

goto bad_fork_cleanup_count;

1089

goto bad_fork_cleanup_count;

1086

1090

1087

if (!try_module_get(task_thread_info(p)->exec_domain->module))

1091

if (!try_module_get(task_thread_info(p)->exec_domain->module))

1088

goto bad_fork_cleanup_count;

1092

goto bad_fork_cleanup_count;

1089

1093

1090

if (p->binfmt && !try_module_get(p->binfmt->module))

1094

if (p->binfmt && !try_module_get(p->binfmt->module))

1091

goto bad_fork_cleanup_put_domain;

1095

goto bad_fork_cleanup_put_domain;

1092

1096

1093

p->did_exec = 0;

1097

p->did_exec = 0;

1094

delayacct_tsk_init(p); /* Must remain after dup_task_struct() */

1098

delayacct_tsk_init(p); /* Must remain after dup_task_struct() */

1095

copy_flags(clone_flags, p);

1099

copy_flags(clone_flags, p);

1096

INIT_LIST_HEAD(&p->children);

1100

INIT_LIST_HEAD(&p->children);

1097

INIT_LIST_HEAD(&p->sibling);

1101

INIT_LIST_HEAD(&p->sibling);

1098

#ifdef CONFIG_PREEMPT_RCU

1102

#ifdef CONFIG_PREEMPT_RCU

1099

p->rcu_read_lock_nesting = 0;

1103

p->rcu_read_lock_nesting = 0;

1100

p->rcu_flipctr_idx = 0;

1104

p->rcu_flipctr_idx = 0;

1101

#endif /* #ifdef CONFIG_PREEMPT_RCU */

1105

#endif /* #ifdef CONFIG_PREEMPT_RCU */

1102

p->vfork_done = NULL;

1106

p->vfork_done = NULL;

1103

spin_lock_init(&p->alloc_lock);

1107

spin_lock_init(&p->alloc_lock);

1104

1108

1105

clear_tsk_thread_flag(p, TIF_SIGPENDING);

1109

clear_tsk_thread_flag(p, TIF_SIGPENDING);

1106

init_sigpending(&p->pending);

1110

init_sigpending(&p->pending);

1107

1111

1108

p->utime = cputime_zero;

1112

p->utime = cputime_zero;

1109

p->stime = cputime_zero;

1113

p->stime = cputime_zero;

1110

p->gtime = cputime_zero;

1114

p->gtime = cputime_zero;

1111

p->utimescaled = cputime_zero;

1115

p->utimescaled = cputime_zero;

1112

p->stimescaled = cputime_zero;

1116

p->stimescaled = cputime_zero;

1113

p->prev_utime = cputime_zero;

1117

p->prev_utime = cputime_zero;

1114

p->prev_stime = cputime_zero;

1118

p->prev_stime = cputime_zero;

1115

1119

1116

#ifdef CONFIG_DETECT_SOFTLOCKUP

1120

#ifdef CONFIG_DETECT_SOFTLOCKUP

1117

p->last_switch_count = 0;

1121

p->last_switch_count = 0;

1118

p->last_switch_timestamp = 0;

1122

p->last_switch_timestamp = 0;

1119

#endif

1123

#endif

1120

1124

1121

#ifdef CONFIG_TASK_XACCT

1125

#ifdef CONFIG_TASK_XACCT

1122

p->rchar = 0; /* I/O counter: bytes read */

1126

p->rchar = 0; /* I/O counter: bytes read */

1123

p->wchar = 0; /* I/O counter: bytes written */

1127

p->wchar = 0; /* I/O counter: bytes written */

1124

p->syscr = 0; /* I/O counter: read syscalls */

1128

p->syscr = 0; /* I/O counter: read syscalls */

1125

p->syscw = 0; /* I/O counter: write syscalls */

1129

p->syscw = 0; /* I/O counter: write syscalls */

1126

#endif

1130

#endif

1127

task_io_accounting_init(p);

1131

task_io_accounting_init(p);

1128

acct_clear_integrals(p);

1132

acct_clear_integrals(p);

1129

1133

1130

p->it_virt_expires = cputime_zero;

1134

p->it_virt_expires = cputime_zero;

1131

p->it_prof_expires = cputime_zero;

1135

p->it_prof_expires = cputime_zero;

1132

p->it_sched_expires = 0;

1136

p->it_sched_expires = 0;

1133

INIT_LIST_HEAD(&p->cpu_timers[0]);

1137

INIT_LIST_HEAD(&p->cpu_timers[0]);

1134

INIT_LIST_HEAD(&p->cpu_timers[1]);

1138

INIT_LIST_HEAD(&p->cpu_timers[1]);

1135

INIT_LIST_HEAD(&p->cpu_timers[2]);

1139

INIT_LIST_HEAD(&p->cpu_timers[2]);

1136

1140

1137

p->lock_depth = -1; /* -1 = no lock */

1141

p->lock_depth = -1; /* -1 = no lock */

1138

do_posix_clock_monotonic_gettime(&p->start_time);

1142

do_posix_clock_monotonic_gettime(&p->start_time);

1139

p->real_start_time = p->start_time;

1143

p->real_start_time = p->start_time;

1140

monotonic_to_bootbased(&p->real_start_time);

1144

monotonic_to_bootbased(&p->real_start_time);

1141

#ifdef CONFIG_SECURITY

1145

#ifdef CONFIG_SECURITY

1142

p->security = NULL;

1146

p->security = NULL;

1143

#endif

1147

#endif

1144

p->cap_bset = current->cap_bset;

1148

p->cap_bset = current->cap_bset;

1145

p->io_context = NULL;

1149

p->io_context = NULL;

1146

p->audit_context = NULL;

1150

p->audit_context = NULL;

1147

cgroup_fork(p);

1151

cgroup_fork(p);

1148

#ifdef CONFIG_NUMA

1152

#ifdef CONFIG_NUMA

1149

p->mempolicy = mpol_copy(p->mempolicy);

1153

p->mempolicy = mpol_copy(p->mempolicy);

1150

if (IS_ERR(p->mempolicy)) {

1154

if (IS_ERR(p->mempolicy)) {

1151

retval = PTR_ERR(p->mempolicy);

1155

retval = PTR_ERR(p->mempolicy);

1152

p->mempolicy = NULL;

1156

p->mempolicy = NULL;

1153

goto bad_fork_cleanup_cgroup;

1157

goto bad_fork_cleanup_cgroup;

1154

}

1158

}

1155

mpol_fix_fork_child_flag(p);

1159

mpol_fix_fork_child_flag(p);

1156

#endif

1160

#endif

1157

#ifdef CONFIG_TRACE_IRQFLAGS

1161

#ifdef CONFIG_TRACE_IRQFLAGS

1158

p->irq_events = 0;

1162

p->irq_events = 0;

1159

#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW

1163

#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW

1160

p->hardirqs_enabled = 1;

1164

p->hardirqs_enabled = 1;

1161

#else

1165

#else

1162

p->hardirqs_enabled = 0;

1166

p->hardirqs_enabled = 0;

1163

#endif

1167

#endif

1164

p->hardirq_enable_ip = 0;

1168

p->hardirq_enable_ip = 0;

1165

p->hardirq_enable_event = 0;

1169

p->hardirq_enable_event = 0;

1166

p->hardirq_disable_ip = _THIS_IP_;

1170

p->hardirq_disable_ip = _THIS_IP_;

1167

p->hardirq_disable_event = 0;

1171

p->hardirq_disable_event = 0;

1168

p->softirqs_enabled = 1;

1172

p->softirqs_enabled = 1;

1169

p->softirq_enable_ip = _THIS_IP_;

1173

p->softirq_enable_ip = _THIS_IP_;

1170

p->softirq_enable_event = 0;

1174

p->softirq_enable_event = 0;

1171

p->softirq_disable_ip = 0;

1175

p->softirq_disable_ip = 0;

1172

p->softirq_disable_event = 0;

1176

p->softirq_disable_event = 0;

1173

p->hardirq_context = 0;

1177

p->hardirq_context = 0;

1174

p->softirq_context = 0;

1178

p->softirq_context = 0;

1175

#endif

1179

#endif

1176

#ifdef CONFIG_LOCKDEP

1180

#ifdef CONFIG_LOCKDEP

1177

p->lockdep_depth = 0; /* no locks held yet */

1181

p->lockdep_depth = 0; /* no locks held yet */

1178

p->curr_chain_key = 0;

1182

p->curr_chain_key = 0;

1179

p->lockdep_recursion = 0;

1183

p->lockdep_recursion = 0;

1180

#endif

1184

#endif

1181

1185

1182

#ifdef CONFIG_DEBUG_MUTEXES

1186

#ifdef CONFIG_DEBUG_MUTEXES

1183

p->blocked_on = NULL; /* not blocked yet */

1187

p->blocked_on = NULL; /* not blocked yet */

1184

#endif

1188

#endif

1185

1189

1186

/* Perform scheduler related setup. Assign this task to a CPU. */

1190

/* Perform scheduler related setup. Assign this task to a CPU. */

1187

sched_fork(p, clone_flags);

1191

sched_fork(p, clone_flags);

1188

1192

1189

if ((retval = security_task_alloc(p)))

1193

if ((retval = security_task_alloc(p)))

1190

goto bad_fork_cleanup_policy;

1194

goto bad_fork_cleanup_policy;

1191

if ((retval = audit_alloc(p)))

1195

if ((retval = audit_alloc(p)))

1192

goto bad_fork_cleanup_security;

1196

goto bad_fork_cleanup_security;

1193

/* copy all the process information */

1197

/* copy all the process information */

1194

if ((retval = copy_semundo(clone_flags, p)))

1198

if ((retval = copy_semundo(clone_flags, p)))

1195

goto bad_fork_cleanup_audit;

1199

goto bad_fork_cleanup_audit;

1196

if ((retval = copy_files(clone_flags, p)))

1200

if ((retval = copy_files(clone_flags, p)))

1197

goto bad_fork_cleanup_semundo;

1201

goto bad_fork_cleanup_semundo;

1198

if ((retval = copy_fs(clone_flags, p)))

1202

if ((retval = copy_fs(clone_flags, p)))

1199

goto bad_fork_cleanup_files;

1203

goto bad_fork_cleanup_files;

1200

if ((retval = copy_sighand(clone_flags, p)))

1204

if ((retval = copy_sighand(clone_flags, p)))

1201

goto bad_fork_cleanup_fs;

1205

goto bad_fork_cleanup_fs;

1202

if ((retval = copy_signal(clone_flags, p)))

1206

if ((retval = copy_signal(clone_flags, p)))

1203

goto bad_fork_cleanup_sighand;

1207

goto bad_fork_cleanup_sighand;

1204

if ((retval = copy_mm(clone_flags, p)))

1208

if ((retval = copy_mm(clone_flags, p)))

1205

goto bad_fork_cleanup_signal;

1209

goto bad_fork_cleanup_signal;

1206

if ((retval = copy_keys(clone_flags, p)))

1210

if ((retval = copy_keys(clone_flags, p)))

1207

goto bad_fork_cleanup_mm;

1211

goto bad_fork_cleanup_mm;

1208

if ((retval = copy_namespaces(clone_flags, p)))

1212

if ((retval = copy_namespaces(clone_flags, p)))

1209

goto bad_fork_cleanup_keys;

1213

goto bad_fork_cleanup_keys;

1210

if ((retval = copy_io(clone_flags, p)))

1214

if ((retval = copy_io(clone_flags, p)))

1211

goto bad_fork_cleanup_namespaces;

1215

goto bad_fork_cleanup_namespaces;

1212

retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);

1216

retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);

1213

if (retval)

1217

if (retval)

1214

goto bad_fork_cleanup_io;

1218

goto bad_fork_cleanup_io;

1215

1219

1216

if (pid != &init_struct_pid) {

1220

if (pid != &init_struct_pid) {

1217

retval = -ENOMEM;

1221

retval = -ENOMEM;

1218

pid = alloc_pid(task_active_pid_ns(p));

1222

pid = alloc_pid(task_active_pid_ns(p));

1219

if (!pid)

1223

if (!pid)

1220

goto bad_fork_cleanup_io;

1224

goto bad_fork_cleanup_io;

1221

1225

1222

if (clone_flags & CLONE_NEWPID) {

1226

if (clone_flags & CLONE_NEWPID) {

1223

retval = pid_ns_prepare_proc(task_active_pid_ns(p));

1227

retval = pid_ns_prepare_proc(task_active_pid_ns(p));

1224

if (retval < 0)

1228

if (retval < 0)

1225

goto bad_fork_free_pid;

1229

goto bad_fork_free_pid;

1226

}

1230

}

1227

}

1231

}

1228

1232

1229

p->pid = pid_nr(pid);

1233

p->pid = pid_nr(pid);

1230

p->tgid = p->pid;

1234

p->tgid = p->pid;

1231

if (clone_flags & CLONE_THREAD)

1235

if (clone_flags & CLONE_THREAD)

1232

p->tgid = current->tgid;

1236

p->tgid = current->tgid;

1233

1237

1234

p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;

1238

p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;

1235

/*

1239

/*

1236

* Clear TID on mm_release()?

1240

* Clear TID on mm_release()?

1237

*/

1241

*/

1238

p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;

1242

p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;

1239

#ifdef CONFIG_FUTEX

1243

#ifdef CONFIG_FUTEX

1240

p->robust_list = NULL;

1244

p->robust_list = NULL;

1241

#ifdef CONFIG_COMPAT

1245

#ifdef CONFIG_COMPAT

1242

p->compat_robust_list = NULL;

1246

p->compat_robust_list = NULL;

1243

#endif

1247

#endif

1244

INIT_LIST_HEAD(&p->pi_state_list);

1248

INIT_LIST_HEAD(&p->pi_state_list);

1245

p->pi_state_cache = NULL;

1249

p->pi_state_cache = NULL;

1246

#endif

1250

#endif

1247

/*

1251

/*

1248

* sigaltstack should be cleared when sharing the same VM

1252

* sigaltstack should be cleared when sharing the same VM

1249

*/

1253

*/

1250

if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)

1254

if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)

1251

p->sas_ss_sp = p->sas_ss_size = 0;

1255

p->sas_ss_sp = p->sas_ss_size = 0;

1252

1256

1253

/*

1257

/*

1254

* Syscall tracing should be turned off in the child regardless

1258

* Syscall tracing should be turned off in the child regardless

1255

* of CLONE_PTRACE.

1259

* of CLONE_PTRACE.

1256

*/

1260

*/

1257

clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);

1261

clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);

1258

#ifdef TIF_SYSCALL_EMU

1262

#ifdef TIF_SYSCALL_EMU

1259

clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);

1263

clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);

1260

#endif

1264

#endif

1261

clear_all_latency_tracing(p);

1265

clear_all_latency_tracing(p);

1262

1266

1263

/* Our parent execution domain becomes current domain

1267

/* Our parent execution domain becomes current domain

1264

These must match for thread signalling to apply */

1268

These must match for thread signalling to apply */

1265

p->parent_exec_id = p->self_exec_id;

1269

p->parent_exec_id = p->self_exec_id;

1266

1270

1267

/* ok, now we should be set up.. */

1271

/* ok, now we should be set up.. */

1268

p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);

1272

p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);

1269

p->pdeath_signal = 0;

1273

p->pdeath_signal = 0;

1270

p->exit_state = 0;

1274

p->exit_state = 0;

1271

1275

1272

/*

1276

/*

1273

* Ok, make it visible to the rest of the system.

1277

* Ok, make it visible to the rest of the system.

1274

* We dont wake it up yet.

1278

* We dont wake it up yet.

1275

*/

1279

*/

1276

p->group_leader = p;

1280

p->group_leader = p;

1277

INIT_LIST_HEAD(&p->thread_group);

1281

INIT_LIST_HEAD(&p->thread_group);

1278

INIT_LIST_HEAD(&p->ptrace_children);

1282

INIT_LIST_HEAD(&p->ptrace_children);

1279

INIT_LIST_HEAD(&p->ptrace_list);

1283

INIT_LIST_HEAD(&p->ptrace_list);

1280

1284

1281

/* Now that the task is set up, run cgroup callbacks if

1285

/* Now that the task is set up, run cgroup callbacks if

1282

* necessary. We need to run them before the task is visible

1286

* necessary. We need to run them before the task is visible

1283

* on the tasklist. */

1287

* on the tasklist. */

1284

cgroup_fork_callbacks(p);

1288

cgroup_fork_callbacks(p);

1285

cgroup_callbacks_done = 1;

1289

cgroup_callbacks_done = 1;

1286

1290

1287

/* Need tasklist lock for parent etc handling! */

1291

/* Need tasklist lock for parent etc handling! */

1288

write_lock_irq(&tasklist_lock);

1292

write_lock_irq(&tasklist_lock);

1289

1293

1290

/*

1294

/*

1291

* The task hasn't been attached yet, so its cpus_allowed mask will

1295

* The task hasn't been attached yet, so its cpus_allowed mask will

1292

* not be changed, nor will its assigned CPU.

1296

* not be changed, nor will its assigned CPU.

1293

*

1297

*

1294

* The cpus_allowed mask of the parent may have changed after it was

1298

* The cpus_allowed mask of the parent may have changed after it was

1295

* copied first time - so re-copy it here, then check the child's CPU

1299

* copied first time - so re-copy it here, then check the child's CPU

1296

* to ensure it is on a valid CPU (and if not, just force it back to

1300

* to ensure it is on a valid CPU (and if not, just force it back to

1297

* parent's CPU). This avoids alot of nasty races.

1301

* parent's CPU). This avoids alot of nasty races.

1298

*/

1302

*/

1299

p->cpus_allowed = current->cpus_allowed;

1303

p->cpus_allowed = current->cpus_allowed;

1300

p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed;

1304

p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed;

1301

if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||

1305

if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||

1302

!cpu_online(task_cpu(p))))

1306

!cpu_online(task_cpu(p))))

1303

set_task_cpu(p, smp_processor_id());

1307

set_task_cpu(p, smp_processor_id());

1304

1308

1305

/* CLONE_PARENT re-uses the old parent */

1309

/* CLONE_PARENT re-uses the old parent */

1306

if (clone_flags & (CLONE_PARENT|CLONE_THREAD))

1310

if (clone_flags & (CLONE_PARENT|CLONE_THREAD))

1307

p->real_parent = current->real_parent;

1311

p->real_parent = current->real_parent;

1308

else

1312

else

1309

p->real_parent = current;

1313

p->real_parent = current;

1310

p->parent = p->real_parent;

1314

p->parent = p->real_parent;

1311

1315

1312

spin_lock(&current->sighand->siglock);

1316

spin_lock(&current->sighand->siglock);

1313

1317

1314

/*

1318

/*

1315

* Process group and session signals need to be delivered to just the

1319

* Process group and session signals need to be delivered to just the

1316

* parent before the fork or both the parent and the child after the

1320

* parent before the fork or both the parent and the child after the

1317

* fork. Restart if a signal comes in before we add the new process to

1321

* fork. Restart if a signal comes in before we add the new process to

1318

* it's process group.

1322

* it's process group.

1319

* A fatal signal pending means that current will exit, so the new

1323

* A fatal signal pending means that current will exit, so the new

1320

* thread can't slip out of an OOM kill (or normal SIGKILL).

1324

* thread can't slip out of an OOM kill (or normal SIGKILL).

1321

*/

1325

*/

1322

recalc_sigpending();

1326

recalc_sigpending();

1323

if (signal_pending(current)) {

1327

if (signal_pending(current)) {

1324

spin_unlock(&current->sighand->siglock);

1328

spin_unlock(&current->sighand->siglock);

1325

write_unlock_irq(&tasklist_lock);

1329

write_unlock_irq(&tasklist_lock);

1326

retval = -ERESTARTNOINTR;

1330

retval = -ERESTARTNOINTR;

1327

goto bad_fork_free_pid;

1331

goto bad_fork_free_pid;

1328

}

1332

}

1329

1333

1330

if (clone_flags & CLONE_THREAD) {

1334

if (clone_flags & CLONE_THREAD) {

1331

p->group_leader = current->group_leader;

1335

p->group_leader = current->group_leader;

1332

list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);

1336

list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);

1333

1337

1334

if (!cputime_eq(current->signal->it_virt_expires,

1338

if (!cputime_eq(current->signal->it_virt_expires,

1335

cputime_zero) ||

1339

cputime_zero) ||

1336

!cputime_eq(current->signal->it_prof_expires,

1340

!cputime_eq(current->signal->it_prof_expires,

1337

cputime_zero) ||

1341

cputime_zero) ||

1338

current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||

1342

current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||

1339

!list_empty(&current->signal->cpu_timers[0]) ||

1343

!list_empty(&current->signal->cpu_timers[0]) ||

1340

!list_empty(&current->signal->cpu_timers[1]) ||

1344

!list_empty(&current->signal->cpu_timers[1]) ||

1341

!list_empty(&current->signal->cpu_timers[2])) {

1345

!list_empty(&current->signal->cpu_timers[2])) {

1342

/*

1346

/*

1343

* Have child wake up on its first tick to check

1347

* Have child wake up on its first tick to check

1344

* for process CPU timers.

1348

* for process CPU timers.

1345

*/

1349

*/

1346

p->it_prof_expires = jiffies_to_cputime(1);

1350

p->it_prof_expires = jiffies_to_cputime(1);

1347

}

1351

}

1348

}

1352

}

1349

1353

1350

if (likely(p->pid)) {

1354

if (likely(p->pid)) {

1351

add_parent(p);

1355

add_parent(p);

1352

if (unlikely(p->ptrace & PT_PTRACED))

1356

if (unlikely(p->ptrace & PT_PTRACED))

1353

__ptrace_link(p, current->parent);

1357

__ptrace_link(p, current->parent);

1354

1358

1355

if (thread_group_leader(p)) {

1359

if (thread_group_leader(p)) {

1356

if (clone_flags & CLONE_NEWPID)

1360

if (clone_flags & CLONE_NEWPID)

1357

p->nsproxy->pid_ns->child_reaper = p;

1361

p->nsproxy->pid_ns->child_reaper = p;

1358

1362

1359

p->signal->leader_pid = pid;

1363

p->signal->leader_pid = pid;

1360

p->signal->tty = current->signal->tty;

1364

p->signal->tty = current->signal->tty;

1361

set_task_pgrp(p, task_pgrp_nr(current));

1365

set_task_pgrp(p, task_pgrp_nr(current));

1362

set_task_session(p, task_session_nr(current));

1366

set_task_session(p, task_session_nr(current));

1363

attach_pid(p, PIDTYPE_PGID, task_pgrp(current));

1367

attach_pid(p, PIDTYPE_PGID, task_pgrp(current));

1364

attach_pid(p, PIDTYPE_SID, task_session(current));

1368

attach_pid(p, PIDTYPE_SID, task_session(current));

1365

list_add_tail_rcu(&p->tasks, &init_task.tasks);

1369

list_add_tail_rcu(&p->tasks, &init_task.tasks);

1366

__get_cpu_var(process_counts)++;

1370

__get_cpu_var(process_counts)++;

1367

}

1371

}

1368

attach_pid(p, PIDTYPE_PID, pid);

1372

attach_pid(p, PIDTYPE_PID, pid);

1369

nr_threads++;

1373

nr_threads++;

1370

}

1374

}

1371

1375

1372

total_forks++;

1376

total_forks++;

1373

spin_unlock(&current->sighand->siglock);

1377

spin_unlock(&current->sighand->siglock);

1374

write_unlock_irq(&tasklist_lock);

1378

write_unlock_irq(&tasklist_lock);

1375

proc_fork_connector(p);

1379

proc_fork_connector(p);

1376

cgroup_post_fork(p);

1380

cgroup_post_fork(p);

1377

return p;

1381

return p;

1378

1382

1379

bad_fork_free_pid:

1383

bad_fork_free_pid:

1380

if (pid != &init_struct_pid)

1384

if (pid != &init_struct_pid)

1381

free_pid(pid);

1385

free_pid(pid);

1382

bad_fork_cleanup_io:

1386

bad_fork_cleanup_io:

1383

put_io_context(p->io_context);

1387

put_io_context(p->io_context);

1384

bad_fork_cleanup_namespaces:

1388

bad_fork_cleanup_namespaces:

1385

exit_task_namespaces(p);

1389

exit_task_namespaces(p);

1386

bad_fork_cleanup_keys:

1390

bad_fork_cleanup_keys:

1387

exit_keys(p);

1391

exit_keys(p);

1388

bad_fork_cleanup_mm:

1392

bad_fork_cleanup_mm:

1389

if (p->mm)

1393

if (p->mm)

1390

mmput(p->mm);

1394

mmput(p->mm);

1391

bad_fork_cleanup_signal:

1395

bad_fork_cleanup_signal:

1392

cleanup_signal(p);

1396

cleanup_signal(p);

1393

bad_fork_cleanup_sighand:

1397

bad_fork_cleanup_sighand:

1394

__cleanup_sighand(p->sighand);

1398

__cleanup_sighand(p->sighand);

1395

bad_fork_cleanup_fs:

1399

bad_fork_cleanup_fs:

1396

exit_fs(p); /* blocking */

1400

exit_fs(p); /* blocking */

1397

bad_fork_cleanup_files:

1401

bad_fork_cleanup_files:

1398

exit_files(p); /* blocking */

1402

exit_files(p); /* blocking */

1399

bad_fork_cleanup_semundo:

1403

bad_fork_cleanup_semundo:

1400

exit_sem(p);

1404

exit_sem(p);

1401

bad_fork_cleanup_audit:

1405

bad_fork_cleanup_audit:

1402

audit_free(p);

1406

audit_free(p);

1403

bad_fork_cleanup_security:

1407

bad_fork_cleanup_security:

1404

security_task_free(p);

1408

security_task_free(p);

1405

bad_fork_cleanup_policy:

1409

bad_fork_cleanup_policy:

1406

#ifdef CONFIG_NUMA

1410

#ifdef CONFIG_NUMA

1407

mpol_free(p->mempolicy);

1411

mpol_free(p->mempolicy);

1408

bad_fork_cleanup_cgroup:

1412

bad_fork_cleanup_cgroup:

1409

#endif

1413

#endif

1410

cgroup_exit(p, cgroup_callbacks_done);

1414

cgroup_exit(p, cgroup_callbacks_done);

1411

delayacct_tsk_free(p);

1415

delayacct_tsk_free(p);

1412

if (p->binfmt)

1416

if (p->binfmt)

1413

module_put(p->binfmt->module);

1417

module_put(p->binfmt->module);

1414

bad_fork_cleanup_put_domain:

1418

bad_fork_cleanup_put_domain:

1415

module_put(task_thread_info(p)->exec_domain->module);

1419

module_put(task_thread_info(p)->exec_domain->module);

1416

bad_fork_cleanup_count:

1420

bad_fork_cleanup_count:

1417

put_group_info(p->group_info);

1421

put_group_info(p->group_info);

1418

atomic_dec(&p->user->processes);

1422

atomic_dec(&p->user->processes);

1419

free_uid(p->user);

1423

free_uid(p->user);

1420

bad_fork_free:

1424

bad_fork_free:

1421

free_task(p);

1425

free_task(p);

1422

fork_out:

1426

fork_out:

1423

return ERR_PTR(retval);

1427

return ERR_PTR(retval);

1424

}

1428

}

1425

1429

1426

noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)

1430

noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)

1427

{

1431

{

1428

memset(regs, 0, sizeof(struct pt_regs));

1432

memset(regs, 0, sizeof(struct pt_regs));

1429

return regs;

1433

return regs;

1430

}

1434

}

1431

1435

1432

struct task_struct * __cpuinit fork_idle(int cpu)

1436

struct task_struct * __cpuinit fork_idle(int cpu)

1433

{

1437

{

1434

struct task_struct *task;

1438

struct task_struct *task;

1435

struct pt_regs regs;

1439

struct pt_regs regs;

1436

1440

1437

task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,

1441

task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,

1438

&init_struct_pid);

1442

&init_struct_pid);

1439

if (!IS_ERR(task))

1443

if (!IS_ERR(task))

1440

init_idle(task, cpu);

1444

init_idle(task, cpu);

1441

1445

1442

return task;

1446

return task;

1443

}

1447

}

1444

1448

1445

static int fork_traceflag(unsigned clone_flags)

1449

static int fork_traceflag(unsigned clone_flags)

1446

{

1450

{

1447

if (clone_flags & CLONE_UNTRACED)

1451

if (clone_flags & CLONE_UNTRACED)

1448

return 0;

1452

return 0;

1449

else if (clone_flags & CLONE_VFORK) {

1453

else if (clone_flags & CLONE_VFORK) {

1450

if (current->ptrace & PT_TRACE_VFORK)

1454

if (current->ptrace & PT_TRACE_VFORK)

1451

return PTRACE_EVENT_VFORK;

1455

return PTRACE_EVENT_VFORK;

1452

} else if ((clone_flags & CSIGNAL) != SIGCHLD) {

1456

} else if ((clone_flags & CSIGNAL) != SIGCHLD) {

1453

if (current->ptrace & PT_TRACE_CLONE)

1457

if (current->ptrace & PT_TRACE_CLONE)

1454

return PTRACE_EVENT_CLONE;

1458

return PTRACE_EVENT_CLONE;

1455

} else if (current->ptrace & PT_TRACE_FORK)

1459

} else if (current->ptrace & PT_TRACE_FORK)

1456

return PTRACE_EVENT_FORK;

1460

return PTRACE_EVENT_FORK;

1457

1461

1458

return 0;

1462

return 0;

1459

}

1463

}

1460

1464

1461

/*

1465

/*

1462

* Ok, this is the main fork-routine.

1466

* Ok, this is the main fork-routine.

1463

*

1467

*

1464

* It copies the process, and if successful kick-starts

1468

* It copies the process, and if successful kick-starts

1465

* it and waits for it to finish using the VM if required.

1469

* it and waits for it to finish using the VM if required.

1466

*/

1470

*/

1467

long do_fork(unsigned long clone_flags,

1471

long do_fork(unsigned long clone_flags,

1468

unsigned long stack_start,

1472

unsigned long stack_start,

1469

struct pt_regs *regs,

1473

struct pt_regs *regs,

1470

unsigned long stack_size,

1474

unsigned long stack_size,

1471

int __user *parent_tidptr,

1475

int __user *parent_tidptr,

1472

int __user *child_tidptr)

1476

int __user *child_tidptr)

1473

{

1477

{

1474

struct task_struct *p;

1478

struct task_struct *p;

1475

int trace = 0;

1479

int trace = 0;

1476

long nr;

1480

long nr;

1477

1481

1478

/*

1482

/*

1479

* We hope to recycle these flags after 2.6.26

1483

* We hope to recycle these flags after 2.6.26

1480

*/

1484

*/

1481

if (unlikely(clone_flags & CLONE_STOPPED)) {

1485

if (unlikely(clone_flags & CLONE_STOPPED)) {

1482

static int __read_mostly count = 100;

1486

static int __read_mostly count = 100;

1483

1487

1484

if (count > 0 && printk_ratelimit()) {

1488

if (count > 0 && printk_ratelimit()) {

1485

char comm[TASK_COMM_LEN];

1489

char comm[TASK_COMM_LEN];

1486

1490

1487

count--;

1491

count--;

1488

printk(KERN_INFO "fork(): process `%s' used deprecated "

1492

printk(KERN_INFO "fork(): process `%s' used deprecated "

1489

"clone flags 0x%lx\n",

1493

"clone flags 0x%lx\n",

1490

get_task_comm(comm, current),

1494

get_task_comm(comm, current),

1491

clone_flags & CLONE_STOPPED);

1495

clone_flags & CLONE_STOPPED);

1492

}

1496

}

1493

}

1497

}

1494

1498

1495

if (unlikely(current->ptrace)) {

1499

if (unlikely(current->ptrace)) {

1496

trace = fork_traceflag (clone_flags);

1500

trace = fork_traceflag (clone_flags);

1497

if (trace)

1501

if (trace)

1498

clone_flags |= CLONE_PTRACE;

1502

clone_flags |= CLONE_PTRACE;

1499

}

1503

}

1500

1504

1501

p = copy_process(clone_flags, stack_start, regs, stack_size,

1505

p = copy_process(clone_flags, stack_start, regs, stack_size,

1502

child_tidptr, NULL);

1506

child_tidptr, NULL);

1503

/*

1507

/*

1504

* Do this prior waking up the new thread - the thread pointer

1508

* Do this prior waking up the new thread - the thread pointer

1505

* might get invalid after that point, if the thread exits quickly.

1509

* might get invalid after that point, if the thread exits quickly.

1506

*/

1510

*/

1507

if (!IS_ERR(p)) {

1511

if (!IS_ERR(p)) {

1508

struct completion vfork;

1512

struct completion vfork;

1509

1513

1510

nr = task_pid_vnr(p);

1514

nr = task_pid_vnr(p);

1511

1515

1512

if (clone_flags & CLONE_PARENT_SETTID)

1516

if (clone_flags & CLONE_PARENT_SETTID)

1513

put_user(nr, parent_tidptr);

1517

put_user(nr, parent_tidptr);

1514

1518

1515

if (clone_flags & CLONE_VFORK) {

1519

if (clone_flags & CLONE_VFORK) {

1516

p->vfork_done = &vfork;

1520

p->vfork_done = &vfork;

1517

init_completion(&vfork);

1521

init_completion(&vfork);

1518

}

1522

}

1519

1523

1520

if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {

1524

if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {

1521

/*

1525

/*

1522

* We'll start up with an immediate SIGSTOP.

1526

* We'll start up with an immediate SIGSTOP.

1523

*/

1527

*/

1524

sigaddset(&p->pending.signal, SIGSTOP);

1528

sigaddset(&p->pending.signal, SIGSTOP);

1525

set_tsk_thread_flag(p, TIF_SIGPENDING);

1529

set_tsk_thread_flag(p, TIF_SIGPENDING);

1526

}

1530

}

1527

1531

1528

if (!(clone_flags & CLONE_STOPPED))

1532

if (!(clone_flags & CLONE_STOPPED))

1529

wake_up_new_task(p, clone_flags);

1533

wake_up_new_task(p, clone_flags);

1530

else

1534

else

1531

__set_task_state(p, TASK_STOPPED);

1535

__set_task_state(p, TASK_STOPPED);

1532

1536

1533

if (unlikely (trace)) {

1537

if (unlikely (trace)) {

1534

current->ptrace_message = nr;

1538

current->ptrace_message = nr;

1535

ptrace_notify ((trace << 8) | SIGTRAP);

1539

ptrace_notify ((trace << 8) | SIGTRAP);

1536

}

1540

}

1537

1541

1538

if (clone_flags & CLONE_VFORK) {

1542

if (clone_flags & CLONE_VFORK) {

1539

freezer_do_not_count();

1543

freezer_do_not_count();

1540

wait_for_completion(&vfork);

1544

wait_for_completion(&vfork);

1541

freezer_count();

1545

freezer_count();

1542

if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {

1546

if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {

1543

current->ptrace_message = nr;

1547

current->ptrace_message = nr;

1544

ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);

1548

ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);

1545

}

1549

}

1546

}

1550

}

1547

} else {

1551

} else {

1548

nr = PTR_ERR(p);

1552

nr = PTR_ERR(p);

1549

}

1553

}

1550

return nr;

1554

return nr;

1551

}

1555

}

1552

1556

1553

#ifndef ARCH_MIN_MMSTRUCT_ALIGN

1557

#ifndef ARCH_MIN_MMSTRUCT_ALIGN

1554

#define ARCH_MIN_MMSTRUCT_ALIGN 0

1558

#define ARCH_MIN_MMSTRUCT_ALIGN 0

1555

#endif

1559

#endif

1556

1560

1557

static void sighand_ctor(struct kmem_cache *cachep, void *data)

1561

static void sighand_ctor(struct kmem_cache *cachep, void *data)

1558

{

1562

{

1559

struct sighand_struct *sighand = data;

1563

struct sighand_struct *sighand = data;

1560

1564

1561

spin_lock_init(&sighand->siglock);

1565

spin_lock_init(&sighand->siglock);

1562

init_waitqueue_head(&sighand->signalfd_wqh);

1566

init_waitqueue_head(&sighand->signalfd_wqh);

1563

}

1567

}

1564

1568

1565

void __init proc_caches_init(void)

1569

void __init proc_caches_init(void)

1566

{

1570

{

1567

sighand_cachep = kmem_cache_create("sighand_cache",

1571

sighand_cachep = kmem_cache_create("sighand_cache",

1568

sizeof(struct sighand_struct), 0,

1572

sizeof(struct sighand_struct), 0,

1569

SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,

1573

SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,

1570

sighand_ctor);

1574

sighand_ctor);

1571

signal_cachep = kmem_cache_create("signal_cache",

1575

signal_cachep = kmem_cache_create("signal_cache",

1572

sizeof(struct signal_struct), 0,

1576

sizeof(struct signal_struct), 0,

1573

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1577

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1574

files_cachep = kmem_cache_create("files_cache",

1578

files_cachep = kmem_cache_create("files_cache",

1575

sizeof(struct files_struct), 0,

1579

sizeof(struct files_struct), 0,

1576

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1580

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1577

fs_cachep = kmem_cache_create("fs_cache",

1581

fs_cachep = kmem_cache_create("fs_cache",

1578

sizeof(struct fs_struct), 0,

1582

sizeof(struct fs_struct), 0,

1579

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1583

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1580

vm_area_cachep = kmem_cache_create("vm_area_struct",

1584

vm_area_cachep = kmem_cache_create("vm_area_struct",

1581

sizeof(struct vm_area_struct), 0,

1585

sizeof(struct vm_area_struct), 0,

1582

SLAB_PANIC, NULL);

1586

SLAB_PANIC, NULL);

1583

mm_cachep = kmem_cache_create("mm_struct",

1587

mm_cachep = kmem_cache_create("mm_struct",

1584

sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,

1588

sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,

1585

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1589

SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

1586

}

1590

}

1587

1591

1588

/*

1592

/*

1589

* Check constraints on flags passed to the unshare system call and

1593

* Check constraints on flags passed to the unshare system call and

1590

* force unsharing of additional process context as appropriate.

1594

* force unsharing of additional process context as appropriate.

1591

*/

1595

*/

1592

static void check_unshare_flags(unsigned long *flags_ptr)

1596

static void check_unshare_flags(unsigned long *flags_ptr)

1593

{

1597

{

1594

/*

1598

/*

1595

* If unsharing a thread from a thread group, must also

1599

* If unsharing a thread from a thread group, must also

1596

* unshare vm.

1600

* unshare vm.

1597

*/

1601

*/

1598

if (*flags_ptr & CLONE_THREAD)

1602

if (*flags_ptr & CLONE_THREAD)

1599

*flags_ptr |= CLONE_VM;

1603

*flags_ptr |= CLONE_VM;

1600

1604

1601

/*

1605

/*

1602

* If unsharing vm, must also unshare signal handlers.

1606

* If unsharing vm, must also unshare signal handlers.

1603

*/

1607

*/

1604

if (*flags_ptr & CLONE_VM)

1608

if (*flags_ptr & CLONE_VM)

1605

*flags_ptr |= CLONE_SIGHAND;

1609

*flags_ptr |= CLONE_SIGHAND;

1606

1610

1607

/*

1611

/*

1608

* If unsharing signal handlers and the task was created

1612

* If unsharing signal handlers and the task was created

1609

* using CLONE_THREAD, then must unshare the thread

1613

* using CLONE_THREAD, then must unshare the thread

1610

*/

1614

*/

1611

if ((*flags_ptr & CLONE_SIGHAND) &&

1615

if ((*flags_ptr & CLONE_SIGHAND) &&

1612

(atomic_read(&current->signal->count) > 1))

1616

(atomic_read(&current->signal->count) > 1))

1613

*flags_ptr |= CLONE_THREAD;

1617

*flags_ptr |= CLONE_THREAD;

1614

1618

1615

/*

1619

/*

1616

* If unsharing namespace, must also unshare filesystem information.

1620

* If unsharing namespace, must also unshare filesystem information.

1617

*/

1621

*/

1618

if (*flags_ptr & CLONE_NEWNS)

1622

if (*flags_ptr & CLONE_NEWNS)

1619

*flags_ptr |= CLONE_FS;

1623

*flags_ptr |= CLONE_FS;

1620

}

1624

}

1621

1625

1622

/*

1626

/*

1623

* Unsharing of tasks created with CLONE_THREAD is not supported yet

1627

* Unsharing of tasks created with CLONE_THREAD is not supported yet

1624

*/

1628

*/

1625

static int unshare_thread(unsigned long unshare_flags)

1629

static int unshare_thread(unsigned long unshare_flags)

1626

{

1630

{

1627

if (unshare_flags & CLONE_THREAD)

1631

if (unshare_flags & CLONE_THREAD)

1628

return -EINVAL;

1632

return -EINVAL;

1629

1633

1630

return 0;

1634

return 0;

1631

}

1635

}

1632

1636

1633

/*

1637

/*

1634

* Unshare the filesystem structure if it is being shared

1638

* Unshare the filesystem structure if it is being shared

1635

*/

1639

*/

1636

static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)

1640

static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)

1637

{

1641

{

1638

struct fs_struct *fs = current->fs;

1642

struct fs_struct *fs = current->fs;

1639

1643

1640

if ((unshare_flags & CLONE_FS) &&

1644

if ((unshare_flags & CLONE_FS) &&

1641

(fs && atomic_read(&fs->count) > 1)) {

1645

(fs && atomic_read(&fs->count) > 1)) {

1642

*new_fsp = __copy_fs_struct(current->fs);

1646

*new_fsp = __copy_fs_struct(current->fs);

1643

if (!*new_fsp)

1647

if (!*new_fsp)

1644

return -ENOMEM;

1648

return -ENOMEM;

1645

}

1649

}

1646

1650

1647

return 0;

1651

return 0;

1648

}

1652

}

1649

1653

1650

/*

1654

/*

1651

* Unsharing of sighand is not supported yet

1655

* Unsharing of sighand is not supported yet

1652

*/

1656

*/

1653

static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)

1657

static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)

1654

{

1658

{

1655

struct sighand_struct *sigh = current->sighand;

1659

struct sighand_struct *sigh = current->sighand;

1656

1660

1657

if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)

1661

if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)

1658

return -EINVAL;

1662

return -EINVAL;

1659

else

1663

else

1660

return 0;

1664

return 0;

1661

}

1665

}

1662

1666

1663

/*

1667

/*

1664

* Unshare vm if it is being shared

1668

* Unshare vm if it is being shared

1665

*/

1669

*/

1666

static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)

1670

static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)

1667

{

1671

{

1668

struct mm_struct *mm = current->mm;

1672

struct mm_struct *mm = current->mm;

1669

1673

1670

if ((unshare_flags & CLONE_VM) &&

1674

if ((unshare_flags & CLONE_VM) &&

1671

(mm && atomic_read(&mm->mm_users) > 1)) {

1675

(mm && atomic_read(&mm->mm_users) > 1)) {

1672

return -EINVAL;

1676

return -EINVAL;

1673

}

1677

}

1674

1678

1675

return 0;

1679

return 0;

1676

}

1680

}

1677

1681

1678

/*

1682

/*

1679

* Unshare file descriptor table if it is being shared

1683

* Unshare file descriptor table if it is being shared

1680

*/

1684

*/

1681

static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)

1685

static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)

1682

{

1686

{

1683

struct files_struct *fd = current->files;

1687

struct files_struct *fd = current->files;

1684

int error = 0;

1688

int error = 0;

1685

1689

1686

if ((unshare_flags & CLONE_FILES) &&

1690

if ((unshare_flags & CLONE_FILES) &&

1687

(fd && atomic_read(&fd->count) > 1)) {

1691

(fd && atomic_read(&fd->count) > 1)) {

1688

*new_fdp = dup_fd(fd, &error);

1692

*new_fdp = dup_fd(fd, &error);

1689

if (!*new_fdp)

1693

if (!*new_fdp)

1690

return error;

1694

return error;

1691

}

1695

}

1692

1696

1693

return 0;

1697

return 0;

1694

}

1698

}

1695

1699

1696

/*

1700

/*

1697

* Unsharing of semundo for tasks created with CLONE_SYSVSEM is not

1701

* Unsharing of semundo for tasks created with CLONE_SYSVSEM is not

1698

* supported yet

1702

* supported yet

1699

*/

1703

*/

1700

static int unshare_semundo(unsigned long unshare_flags, struct sem_undo_list **new_ulistp)

1704

static int unshare_semundo(unsigned long unshare_flags, struct sem_undo_list **new_ulistp)

1701

{

1705

{

1702

if (unshare_flags & CLONE_SYSVSEM)

1706

if (unshare_flags & CLONE_SYSVSEM)

1703

return -EINVAL;

1707

return -EINVAL;

1704

1708

1705

return 0;

1709

return 0;

1706

}

1710

}

1707

1711

1708

/*

1712

/*

1709

* unshare allows a process to 'unshare' part of the process

1713

* unshare allows a process to 'unshare' part of the process

1710

* context which was originally shared using clone. copy_*

1714

* context which was originally shared using clone. copy_*

1711

* functions used by do_fork() cannot be used here directly

1715

* functions used by do_fork() cannot be used here directly

1712

* because they modify an inactive task_struct that is being

1716

* because they modify an inactive task_struct that is being

1713

* constructed. Here we are modifying the current, active,

1717

* constructed. Here we are modifying the current, active,

1714

* task_struct.

1718

* task_struct.

1715

*/

1719

*/

1716

asmlinkage long sys_unshare(unsigned long unshare_flags)

1720

asmlinkage long sys_unshare(unsigned long unshare_flags)

1717

{

1721

{

1718

int err = 0;

1722

int err = 0;

1719

struct fs_struct *fs, *new_fs = NULL;

1723

struct fs_struct *fs, *new_fs = NULL;

1720

struct sighand_struct *new_sigh = NULL;

1724

struct sighand_struct *new_sigh = NULL;

1721

struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;

1725

struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;

1722

struct files_struct *fd, *new_fd = NULL;

1726

struct files_struct *fd, *new_fd = NULL;

1723

struct sem_undo_list *new_ulist = NULL;

1727

struct sem_undo_list *new_ulist = NULL;

1724

struct nsproxy *new_nsproxy = NULL;

1728

struct nsproxy *new_nsproxy = NULL;

1725

1729

1726

check_unshare_flags(&unshare_flags);

1730

check_unshare_flags(&unshare_flags);

1727

1731

1728

/* Return -EINVAL for all unsupported flags */

1732

/* Return -EINVAL for all unsupported flags */

1729

err = -EINVAL;

1733

err = -EINVAL;

1730

if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|

1734

if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|

1731

CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|

1735

CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|

1732

CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWUSER|

1736

CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWUSER|

1733

CLONE_NEWNET))

1737

CLONE_NEWNET))

1734

goto bad_unshare_out;

1738

goto bad_unshare_out;

1735

1739

1736

if ((err = unshare_thread(unshare_flags)))

1740

if ((err = unshare_thread(unshare_flags)))

1737

goto bad_unshare_out;

1741

goto bad_unshare_out;

1738

if ((err = unshare_fs(unshare_flags, &new_fs)))

1742

if ((err = unshare_fs(unshare_flags, &new_fs)))

1739

goto bad_unshare_cleanup_thread;

1743

goto bad_unshare_cleanup_thread;

1740

if ((err = unshare_sighand(unshare_flags, &new_sigh)))

1744

if ((err = unshare_sighand(unshare_flags, &new_sigh)))

1741

goto bad_unshare_cleanup_fs;

1745

goto bad_unshare_cleanup_fs;

1742

if ((err = unshare_vm(unshare_flags, &new_mm)))

1746

if ((err = unshare_vm(unshare_flags, &new_mm)))

1743

goto bad_unshare_cleanup_sigh;

1747

goto bad_unshare_cleanup_sigh;

1744

if ((err = unshare_fd(unshare_flags, &new_fd)))

1748

if ((err = unshare_fd(unshare_flags, &new_fd)))

1745

goto bad_unshare_cleanup_vm;

1749

goto bad_unshare_cleanup_vm;

1746

if ((err = unshare_semundo(unshare_flags, &new_ulist)))

1750

if ((err = unshare_semundo(unshare_flags, &new_ulist)))

1747

goto bad_unshare_cleanup_fd;

1751

goto bad_unshare_cleanup_fd;

1748

if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,

1752

if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,

1749

new_fs)))

1753

new_fs)))

1750

goto bad_unshare_cleanup_semundo;

1754

goto bad_unshare_cleanup_semundo;

1751

1755

1752

if (new_fs || new_mm || new_fd || new_ulist || new_nsproxy) {

1756

if (new_fs || new_mm || new_fd || new_ulist || new_nsproxy) {

1753

1757

1754

if (new_nsproxy) {

1758

if (new_nsproxy) {

1755

switch_task_namespaces(current, new_nsproxy);

1759

switch_task_namespaces(current, new_nsproxy);

1756

new_nsproxy = NULL;

1760

new_nsproxy = NULL;

1757

}

1761

}

1758

1762

1759

task_lock(current);

1763

task_lock(current);

1760

1764

1761

if (new_fs) {

1765

if (new_fs) {

1762

fs = current->fs;

1766

fs = current->fs;

1763

current->fs = new_fs;

1767

current->fs = new_fs;

1764

new_fs = fs;

1768

new_fs = fs;

1765

}

1769

}

1766

1770

1767

if (new_mm) {

1771

if (new_mm) {

1768

mm = current->mm;

1772

mm = current->mm;

1769

active_mm = current->active_mm;

1773

active_mm = current->active_mm;

1770

current->mm = new_mm;

1774

current->mm = new_mm;

1771

current->active_mm = new_mm;

1775

current->active_mm = new_mm;

1772

activate_mm(active_mm, new_mm);

1776

activate_mm(active_mm, new_mm);

1773

new_mm = mm;

1777

new_mm = mm;

1774

}

1778

}

1775

1779

1776

if (new_fd) {

1780

if (new_fd) {

1777

fd = current->files;

1781

fd = current->files;

1778

current->files = new_fd;

1782

current->files = new_fd;

1779

new_fd = fd;

1783

new_fd = fd;

1780

}

1784

}

1781

1785

1782

task_unlock(current);

1786

task_unlock(current);

1783

}

1787

}

1784

1788

1785

if (new_nsproxy)

1789

if (new_nsproxy)

1786

put_nsproxy(new_nsproxy);

1790

put_nsproxy(new_nsproxy);

1787

1791

1788

bad_unshare_cleanup_semundo:

1792

bad_unshare_cleanup_semundo:

1789

bad_unshare_cleanup_fd:

1793

bad_unshare_cleanup_fd:

1790

if (new_fd)

1794

if (new_fd)

1791

put_files_struct(new_fd);

1795

put_files_struct(new_fd);

1792

1796

1793

bad_unshare_cleanup_vm:

1797

bad_unshare_cleanup_vm:

1794

if (new_mm)

1798

if (new_mm)

1795

mmput(new_mm);

1799

mmput(new_mm);

1796

1800

1797

bad_unshare_cleanup_sigh:

1801

bad_unshare_cleanup_sigh:

1798

if (new_sigh)

1802

if (new_sigh)

1799

if (atomic_dec_and_test(&new_sigh->count))

1803

if (atomic_dec_and_test(&new_sigh->count))

1800

kmem_cache_free(sighand_cachep, new_sigh);

1804

kmem_cache_free(sighand_cachep, new_sigh);

1801

1805

1802

bad_unshare_cleanup_fs:

1806

bad_unshare_cleanup_fs:

1803

if (new_fs)

1807

if (new_fs)

1804

put_fs_struct(new_fs);

1808

put_fs_struct(new_fs);

1805

1809

1806

bad_unshare_cleanup_thread:

1810

bad_unshare_cleanup_thread:

1807

bad_unshare_out:

1811

bad_unshare_out:

1808

return err;

1812

return err;

1809

}

1813

}

1810

1814

 #ifndef _ASM_X86_THREAD_INFO_H
 #ifdef CONFIG_X86_32
 # include "thread_info_32.h"
 #else
 # include "thread_info_64.h"
 #endif
 #ifndef __ASSEMBLY__
 extern void arch_task_cache_init(void);
 extern void free_thread_info(struct thread_info *ti);
 extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);
+#define arch_task_cache_init arch_task_cache_init
 #endif
 #endif /* _ASM_X86_THREAD_INFO_H */

GITLAB

x86: fpu xstate split fix

 /*
  *  linux/kernel/fork.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 /*
  *  'fork.c' contains the help-routines for the 'fork' system call
  * (see also entry.S and others).
  * Fork is rather simple, once you get the hang of it, but the memory
  * management can be a bitch. See 'mm/memory.c': 'copy_page_range()'
  */
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/unistd.h>
 #include <linux/module.h>
 #include <linux/vmalloc.h>
 #include <linux/completion.h>
 #include <linux/mnt_namespace.h>
 #include <linux/personality.h>
 #include <linux/mempolicy.h>
 #include <linux/sem.h>
 #include <linux/file.h>
 #include <linux/key.h>
 #include <linux/binfmts.h>
 #include <linux/mman.h>
 #include <linux/fs.h>
 #include <linux/nsproxy.h>
 #include <linux/capability.h>
 #include <linux/cpu.h>
 #include <linux/cgroup.h>
 #include <linux/security.h>
 #include <linux/swap.h>
 #include <linux/syscalls.h>
 #include <linux/jiffies.h>
 #include <linux/futex.h>
 #include <linux/task_io_accounting_ops.h>
 #include <linux/rcupdate.h>
 #include <linux/ptrace.h>
 #include <linux/mount.h>
 #include <linux/audit.h>
 #include <linux/memcontrol.h>
 #include <linux/profile.h>
 #include <linux/rmap.h>
 #include <linux/acct.h>
 #include <linux/tsacct_kern.h>
 #include <linux/cn_proc.h>
 #include <linux/freezer.h>
 #include <linux/delayacct.h>
 #include <linux/taskstats_kern.h>
 #include <linux/random.h>
 #include <linux/tty.h>
 #include <linux/proc_fs.h>
 #include <linux/blkdev.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 /*
  * Protected counters by write_lock_irq(&tasklist_lock)
  */
 unsigned long total_forks;	/* Handle normal Linux uptimes. */
 int nr_threads; 		/* The idle threads do not count.. */
 int max_threads;		/* tunable limit on nr_threads */
 DEFINE_PER_CPU(unsigned long, process_counts) = 0;
 __cacheline_aligned DEFINE_RWLOCK(tasklist_lock);  /* outer */
 int nr_processes(void)
 {
 	int cpu;
 	int total = 0;
 	for_each_online_cpu(cpu)
 		total += per_cpu(process_counts, cpu);
 	return total;
 }
 #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
 # define alloc_task_struct()	kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
 # define free_task_struct(tsk)	kmem_cache_free(task_struct_cachep, (tsk))
 static struct kmem_cache *task_struct_cachep;
 #endif
 /* SLAB cache for signal_struct structures (tsk->signal) */
 static struct kmem_cache *signal_cachep;
 /* SLAB cache for sighand_struct structures (tsk->sighand) */
 struct kmem_cache *sighand_cachep;
 /* SLAB cache for files_struct structures (tsk->files) */
 struct kmem_cache *files_cachep;
 /* SLAB cache for fs_struct structures (tsk->fs) */
 struct kmem_cache *fs_cachep;
 /* SLAB cache for vm_area_struct structures */
 struct kmem_cache *vm_area_cachep;
 /* SLAB cache for mm_struct structures (tsk->mm) */
 static struct kmem_cache *mm_cachep;
 void free_task(struct task_struct *tsk)
 {
 	prop_local_destroy_single(&tsk->dirties);
 	free_thread_info(tsk->stack);
 	rt_mutex_debug_task_free(tsk);
 	free_task_struct(tsk);
 }
 EXPORT_SYMBOL(free_task);
 void __put_task_struct(struct task_struct *tsk)
 {
 	WARN_ON(!tsk->exit_state);
 	WARN_ON(atomic_read(&tsk->usage));
 	WARN_ON(tsk == current);
 	security_task_free(tsk);
 	free_uid(tsk->user);
 	put_group_info(tsk->group_info);
 	delayacct_tsk_free(tsk);
 	if (!profile_handoff_task(tsk))
 		free_task(tsk);
 }
-void __attribute__((weak)) arch_task_cache_init(void)
+/*
-{
+ * macro override instead of weak attribute alias, to workaround
-}
+ * gcc 4.1.0 and 4.1.1 bugs with weak attribute and empty functions.
+ */
+#ifndef arch_task_cache_init
+#define arch_task_cache_init()
+#endif
 void __init fork_init(unsigned long mempages)
 {
 #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
 #ifndef ARCH_MIN_TASKALIGN
 #define ARCH_MIN_TASKALIGN	L1_CACHE_BYTES
 #endif
 	/* create a slab on which task_structs can be allocated */
 	task_struct_cachep =
 		kmem_cache_create("task_struct", sizeof(struct task_struct),
 			ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);
 #endif
 	/* do the arch specific task caches init */
 	arch_task_cache_init();
 	/*
 	 * The default maximum number of threads is set to a safe
 	 * value: the thread structures can take up at most half
 	 * of memory.
 	 */
 	max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
 	/*
 	 * we need to allow at least 20 threads to boot a system
 	 */
 	if(max_threads < 20)
 		max_threads = 20;
 	init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
 	init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
 	init_task.signal->rlim[RLIMIT_SIGPENDING] =
 		init_task.signal->rlim[RLIMIT_NPROC];
 }
 int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst,
 					       struct task_struct *src)
 {
 	*dst = *src;
 	return 0;
 }
 static struct task_struct *dup_task_struct(struct task_struct *orig)
 {
 	struct task_struct *tsk;
 	struct thread_info *ti;
 	int err;
 	prepare_to_copy(orig);
 	tsk = alloc_task_struct();
 	if (!tsk)
 		return NULL;
 	ti = alloc_thread_info(tsk);
 	if (!ti) {
 		free_task_struct(tsk);
 		return NULL;
 	}
  	err = arch_dup_task_struct(tsk, orig);
 	if (err)
 		goto out;
 	tsk->stack = ti;
 	err = prop_local_init_single(&tsk->dirties);
 	if (err)
 		goto out;
 	setup_thread_stack(tsk, orig);
 #ifdef CONFIG_CC_STACKPROTECTOR
 	tsk->stack_canary = get_random_int();
 #endif
 	/* One for us, one for whoever does the "release_task()" (usually parent) */
 	atomic_set(&tsk->usage,2);
 	atomic_set(&tsk->fs_excl, 0);
 #ifdef CONFIG_BLK_DEV_IO_TRACE
 	tsk->btrace_seq = 0;
 #endif
 	tsk->splice_pipe = NULL;
 	return tsk;
 out:
 	free_thread_info(ti);
 	free_task_struct(tsk);
 	return NULL;
 }
 #ifdef CONFIG_MMU
 static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
 {
 	struct vm_area_struct *mpnt, *tmp, **pprev;
 	struct rb_node **rb_link, *rb_parent;
 	int retval;
 	unsigned long charge;
 	struct mempolicy *pol;
 	down_write(&oldmm->mmap_sem);
 	flush_cache_dup_mm(oldmm);
 	/*
 	 * Not linked in yet - no deadlock potential:
 	 */
 	down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
 	mm->locked_vm = 0;
 	mm->mmap = NULL;
 	mm->mmap_cache = NULL;
 	mm->free_area_cache = oldmm->mmap_base;
 	mm->cached_hole_size = ~0UL;
 	mm->map_count = 0;
 	cpus_clear(mm->cpu_vm_mask);
 	mm->mm_rb = RB_ROOT;
 	rb_link = &mm->mm_rb.rb_node;
 	rb_parent = NULL;
 	pprev = &mm->mmap;
 	for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
 		struct file *file;
 		if (mpnt->vm_flags & VM_DONTCOPY) {
 			long pages = vma_pages(mpnt);
 			mm->total_vm -= pages;
 			vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
 								-pages);
 			continue;
 		}
 		charge = 0;
 		if (mpnt->vm_flags & VM_ACCOUNT) {
 			unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
 			if (security_vm_enough_memory(len))
 				goto fail_nomem;
 			charge = len;
 		}
 		tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
 		if (!tmp)
 			goto fail_nomem;
 		*tmp = *mpnt;
 		pol = mpol_copy(vma_policy(mpnt));
 		retval = PTR_ERR(pol);
 		if (IS_ERR(pol))
 			goto fail_nomem_policy;
 		vma_set_policy(tmp, pol);
 		tmp->vm_flags &= ~VM_LOCKED;
 		tmp->vm_mm = mm;
 		tmp->vm_next = NULL;
 		anon_vma_link(tmp);
 		file = tmp->vm_file;
 		if (file) {
 			struct inode *inode = file->f_path.dentry->d_inode;
 			get_file(file);
 			if (tmp->vm_flags & VM_DENYWRITE)
 				atomic_dec(&inode->i_writecount);
 			/* insert tmp into the share list, just after mpnt */
 			spin_lock(&file->f_mapping->i_mmap_lock);
 			tmp->vm_truncate_count = mpnt->vm_truncate_count;
 			flush_dcache_mmap_lock(file->f_mapping);
 			vma_prio_tree_add(tmp, mpnt);
 			flush_dcache_mmap_unlock(file->f_mapping);
 			spin_unlock(&file->f_mapping->i_mmap_lock);
 		}
 		/*
 		 * Link in the new vma and copy the page table entries.
 		 */
 		*pprev = tmp;
 		pprev = &tmp->vm_next;
 		__vma_link_rb(mm, tmp, rb_link, rb_parent);
 		rb_link = &tmp->vm_rb.rb_right;
 		rb_parent = &tmp->vm_rb;
 		mm->map_count++;
 		retval = copy_page_range(mm, oldmm, mpnt);
 		if (tmp->vm_ops && tmp->vm_ops->open)
 			tmp->vm_ops->open(tmp);
 		if (retval)
 			goto out;
 	}
 	/* a new mm has just been created */
 	arch_dup_mmap(oldmm, mm);
 	retval = 0;
 out:
 	up_write(&mm->mmap_sem);
 	flush_tlb_mm(oldmm);
 	up_write(&oldmm->mmap_sem);
 	return retval;
 fail_nomem_policy:
 	kmem_cache_free(vm_area_cachep, tmp);
 fail_nomem:
 	retval = -ENOMEM;
 	vm_unacct_memory(charge);
 	goto out;
 }
 static inline int mm_alloc_pgd(struct mm_struct * mm)
 {
 	mm->pgd = pgd_alloc(mm);
 	if (unlikely(!mm->pgd))
 		return -ENOMEM;
 	return 0;
 }
 static inline void mm_free_pgd(struct mm_struct * mm)
 {
 	pgd_free(mm, mm->pgd);
 }
 #else
 #define dup_mmap(mm, oldmm)	(0)
 #define mm_alloc_pgd(mm)	(0)
 #define mm_free_pgd(mm)
 #endif /* CONFIG_MMU */
 __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
 #define allocate_mm()	(kmem_cache_alloc(mm_cachep, GFP_KERNEL))
 #define free_mm(mm)	(kmem_cache_free(mm_cachep, (mm)))
 #include <linux/init_task.h>
 static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)
 {
 	atomic_set(&mm->mm_users, 1);
 	atomic_set(&mm->mm_count, 1);
 	init_rwsem(&mm->mmap_sem);
 	INIT_LIST_HEAD(&mm->mmlist);
 	mm->flags = (current->mm) ? current->mm->flags
 				  : MMF_DUMP_FILTER_DEFAULT;
 	mm->core_waiters = 0;
 	mm->nr_ptes = 0;
 	set_mm_counter(mm, file_rss, 0);
 	set_mm_counter(mm, anon_rss, 0);
 	spin_lock_init(&mm->page_table_lock);
 	rwlock_init(&mm->ioctx_list_lock);
 	mm->ioctx_list = NULL;
 	mm->free_area_cache = TASK_UNMAPPED_BASE;
 	mm->cached_hole_size = ~0UL;
 	mm_init_cgroup(mm, p);
 	if (likely(!mm_alloc_pgd(mm))) {
 		mm->def_flags = 0;
 		return mm;
 	}
 	mm_free_cgroup(mm);
 	free_mm(mm);
 	return NULL;
 }
 /*
  * Allocate and initialize an mm_struct.
  */
 struct mm_struct * mm_alloc(void)
 {
 	struct mm_struct * mm;
 	mm = allocate_mm();
 	if (mm) {
 		memset(mm, 0, sizeof(*mm));
 		mm = mm_init(mm, current);
 	}
 	return mm;
 }
 /*
  * Called when the last reference to the mm
  * is dropped: either by a lazy thread or by
  * mmput. Free the page directory and the mm.
  */
 void __mmdrop(struct mm_struct *mm)
 {
 	BUG_ON(mm == &init_mm);
 	mm_free_pgd(mm);
 	destroy_context(mm);
 	free_mm(mm);
 }
 EXPORT_SYMBOL_GPL(__mmdrop);
 /*
  * Decrement the use count and release all resources for an mm.
  */
 void mmput(struct mm_struct *mm)
 {
 	might_sleep();
 	if (atomic_dec_and_test(&mm->mm_users)) {
 		exit_aio(mm);
 		exit_mmap(mm);
 		if (!list_empty(&mm->mmlist)) {
 			spin_lock(&mmlist_lock);
 			list_del(&mm->mmlist);
 			spin_unlock(&mmlist_lock);
 		}
 		put_swap_token(mm);
 		mm_free_cgroup(mm);
 		mmdrop(mm);
 	}
 }
 EXPORT_SYMBOL_GPL(mmput);
 /**
  * get_task_mm - acquire a reference to the task's mm
  *
  * Returns %NULL if the task has no mm.  Checks PF_BORROWED_MM (meaning
  * this kernel workthread has transiently adopted a user mm with use_mm,
  * to do its AIO) is not set and if so returns a reference to it, after
  * bumping up the use count.  User must release the mm via mmput()
  * after use.  Typically used by /proc and ptrace.
  */
 struct mm_struct *get_task_mm(struct task_struct *task)
 {
 	struct mm_struct *mm;
 	task_lock(task);
 	mm = task->mm;
 	if (mm) {
 		if (task->flags & PF_BORROWED_MM)
 			mm = NULL;
 		else
 			atomic_inc(&mm->mm_users);
 	}
 	task_unlock(task);
 	return mm;
 }
 EXPORT_SYMBOL_GPL(get_task_mm);
 /* Please note the differences between mmput and mm_release.
  * mmput is called whenever we stop holding onto a mm_struct,
  * error success whatever.
  *
  * mm_release is called after a mm_struct has been removed
  * from the current process.
  *
  * This difference is important for error handling, when we
  * only half set up a mm_struct for a new process and need to restore
  * the old one.  Because we mmput the new mm_struct before
  * restoring the old one. . .
  * Eric Biederman 10 January 1998
  */
 void mm_release(struct task_struct *tsk, struct mm_struct *mm)
 {
 	struct completion *vfork_done = tsk->vfork_done;
 	/* Get rid of any cached register state */
 	deactivate_mm(tsk, mm);
 	/* notify parent sleeping on vfork() */
 	if (vfork_done) {
 		tsk->vfork_done = NULL;
 		complete(vfork_done);
 	}
 	/*
 	 * If we're exiting normally, clear a user-space tid field if
 	 * requested.  We leave this alone when dying by signal, to leave
 	 * the value intact in a core dump, and to save the unnecessary
 	 * trouble otherwise.  Userland only wants this done for a sys_exit.
 	 */
 	if (tsk->clear_child_tid
 	    && !(tsk->flags & PF_SIGNALED)
 	    && atomic_read(&mm->mm_users) > 1) {
 		u32 __user * tidptr = tsk->clear_child_tid;
 		tsk->clear_child_tid = NULL;
 		/*
 		 * We don't check the error code - if userspace has
 		 * not set up a proper pointer then tough luck.
 		 */
 		put_user(0, tidptr);
 		sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
 	}
 }
 /*
  * Allocate a new mm structure and copy contents from the
  * mm structure of the passed in task structure.
  */
 static struct mm_struct *dup_mm(struct task_struct *tsk)
 {
 	struct mm_struct *mm, *oldmm = current->mm;
 	int err;
 	if (!oldmm)
 		return NULL;
 	mm = allocate_mm();
 	if (!mm)
 		goto fail_nomem;
 	memcpy(mm, oldmm, sizeof(*mm));
 	/* Initializing for Swap token stuff */
 	mm->token_priority = 0;
 	mm->last_interval = 0;
 	if (!mm_init(mm, tsk))
 		goto fail_nomem;
 	if (init_new_context(tsk, mm))
 		goto fail_nocontext;
 	err = dup_mmap(mm, oldmm);
 	if (err)
 		goto free_pt;
 	mm->hiwater_rss = get_mm_rss(mm);
 	mm->hiwater_vm = mm->total_vm;
 	return mm;
 free_pt:
 	mmput(mm);
 fail_nomem:
 	return NULL;
 fail_nocontext:
 	/*
 	 * If init_new_context() failed, we cannot use mmput() to free the mm
 	 * because it calls destroy_context()
 	 */
 	mm_free_pgd(mm);
 	free_mm(mm);
 	return NULL;
 }
 static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
 {
 	struct mm_struct * mm, *oldmm;
 	int retval;
 	tsk->min_flt = tsk->maj_flt = 0;
 	tsk->nvcsw = tsk->nivcsw = 0;
 	tsk->mm = NULL;
 	tsk->active_mm = NULL;
 	/*
 	 * Are we cloning a kernel thread?
 	 *
 	 * We need to steal a active VM for that..
 	 */
 	oldmm = current->mm;
 	if (!oldmm)
 		return 0;
 	if (clone_flags & CLONE_VM) {
 		atomic_inc(&oldmm->mm_users);
 		mm = oldmm;
 		goto good_mm;
 	}
 	retval = -ENOMEM;
 	mm = dup_mm(tsk);
 	if (!mm)
 		goto fail_nomem;
 good_mm:
 	/* Initializing for Swap token stuff */
 	mm->token_priority = 0;
 	mm->last_interval = 0;
 	tsk->mm = mm;
 	tsk->active_mm = mm;
 	return 0;
 fail_nomem:
 	return retval;
 }
 static struct fs_struct *__copy_fs_struct(struct fs_struct *old)
 {
 	struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
 	/* We don't need to lock fs - think why ;-) */
 	if (fs) {
 		atomic_set(&fs->count, 1);
 		rwlock_init(&fs->lock);
 		fs->umask = old->umask;
 		read_lock(&old->lock);
 		fs->root = old->root;
 		path_get(&old->root);
 		fs->pwd = old->pwd;
 		path_get(&old->pwd);
 		if (old->altroot.dentry) {
 			fs->altroot = old->altroot;
 			path_get(&old->altroot);
 		} else {
 			fs->altroot.mnt = NULL;
 			fs->altroot.dentry = NULL;
 		}
 		read_unlock(&old->lock);
 	}
 	return fs;
 }
 struct fs_struct *copy_fs_struct(struct fs_struct *old)
 {
 	return __copy_fs_struct(old);
 }
 EXPORT_SYMBOL_GPL(copy_fs_struct);
 static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)
 {
 	if (clone_flags & CLONE_FS) {
 		atomic_inc(&current->fs->count);
 		return 0;
 	}
 	tsk->fs = __copy_fs_struct(current->fs);
 	if (!tsk->fs)
 		return -ENOMEM;
 	return 0;
 }
 static int count_open_files(struct fdtable *fdt)
 {
 	int size = fdt->max_fds;
 	int i;
 	/* Find the last open fd */
 	for (i = size/(8*sizeof(long)); i > 0; ) {
 		if (fdt->open_fds->fds_bits[--i])
 			break;
 	}
 	i = (i+1) * 8 * sizeof(long);
 	return i;
 }
 static struct files_struct *alloc_files(void)
 {
 	struct files_struct *newf;
 	struct fdtable *fdt;
 	newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
 	if (!newf)
 		goto out;
 	atomic_set(&newf->count, 1);
 	spin_lock_init(&newf->file_lock);
 	newf->next_fd = 0;
 	fdt = &newf->fdtab;
 	fdt->max_fds = NR_OPEN_DEFAULT;
 	fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
 	fdt->open_fds = (fd_set *)&newf->open_fds_init;
 	fdt->fd = &newf->fd_array[0];
 	INIT_RCU_HEAD(&fdt->rcu);
 	fdt->next = NULL;
 	rcu_assign_pointer(newf->fdt, fdt);
 out:
 	return newf;
 }
 /*
  * Allocate a new files structure and copy contents from the
  * passed in files structure.
  * errorp will be valid only when the returned files_struct is NULL.
  */
 static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
 {
 	struct files_struct *newf;
 	struct file **old_fds, **new_fds;
 	int open_files, size, i;
 	struct fdtable *old_fdt, *new_fdt;
 	*errorp = -ENOMEM;
 	newf = alloc_files();
 	if (!newf)
 		goto out;
 	spin_lock(&oldf->file_lock);
 	old_fdt = files_fdtable(oldf);
 	new_fdt = files_fdtable(newf);
 	open_files = count_open_files(old_fdt);
 	/*
 	 * Check whether we need to allocate a larger fd array and fd set.
 	 * Note: we're not a clone task, so the open count won't change.
 	 */
 	if (open_files > new_fdt->max_fds) {
 		new_fdt->max_fds = 0;
 		spin_unlock(&oldf->file_lock);
 		spin_lock(&newf->file_lock);
 		*errorp = expand_files(newf, open_files-1);
 		spin_unlock(&newf->file_lock);
 		if (*errorp < 0)
 			goto out_release;
 		new_fdt = files_fdtable(newf);
 		/*
 		 * Reacquire the oldf lock and a pointer to its fd table
 		 * who knows it may have a new bigger fd table. We need
 		 * the latest pointer.
 		 */
 		spin_lock(&oldf->file_lock);
 		old_fdt = files_fdtable(oldf);
 	}
 	old_fds = old_fdt->fd;
 	new_fds = new_fdt->fd;
 	memcpy(new_fdt->open_fds->fds_bits,
 		old_fdt->open_fds->fds_bits, open_files/8);
 	memcpy(new_fdt->close_on_exec->fds_bits,
 		old_fdt->close_on_exec->fds_bits, open_files/8);
 	for (i = open_files; i != 0; i--) {
 		struct file *f = *old_fds++;
 		if (f) {
 			get_file(f);
 		} else {
 			/*
 			 * The fd may be claimed in the fd bitmap but not yet
 			 * instantiated in the files array if a sibling thread
 			 * is partway through open().  So make sure that this
 			 * fd is available to the new process.
 			 */
 			FD_CLR(open_files - i, new_fdt->open_fds);
 		}
 		rcu_assign_pointer(*new_fds++, f);
 	}
 	spin_unlock(&oldf->file_lock);
 	/* compute the remainder to be cleared */
 	size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
 	/* This is long word aligned thus could use a optimized version */
 	memset(new_fds, 0, size);
 	if (new_fdt->max_fds > open_files) {
 		int left = (new_fdt->max_fds-open_files)/8;
 		int start = open_files / (8 * sizeof(unsigned long));
 		memset(&new_fdt->open_fds->fds_bits[start], 0, left);
 		memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
 	}
 	return newf;
 out_release:
 	kmem_cache_free(files_cachep, newf);
 out:
 	return NULL;
 }
 static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
 {
 	struct files_struct *oldf, *newf;
 	int error = 0;
 	/*
 	 * A background process may not have any files ...
 	 */
 	oldf = current->files;
 	if (!oldf)
 		goto out;
 	if (clone_flags & CLONE_FILES) {
 		atomic_inc(&oldf->count);
 		goto out;
 	}
 	/*
 	 * Note: we may be using current for both targets (See exec.c)
 	 * This works because we cache current->files (old) as oldf. Don't
 	 * break this.
 	 */
 	tsk->files = NULL;
 	newf = dup_fd(oldf, &error);
 	if (!newf)
 		goto out;
 	tsk->files = newf;
 	error = 0;
 out:
 	return error;
 }
 static int copy_io(unsigned long clone_flags, struct task_struct *tsk)
 {
 #ifdef CONFIG_BLOCK
 	struct io_context *ioc = current->io_context;
 	if (!ioc)
 		return 0;
 	/*
 	 * Share io context with parent, if CLONE_IO is set
 	 */
 	if (clone_flags & CLONE_IO) {
 		tsk->io_context = ioc_task_link(ioc);
 		if (unlikely(!tsk->io_context))
 			return -ENOMEM;
 	} else if (ioprio_valid(ioc->ioprio)) {
 		tsk->io_context = alloc_io_context(GFP_KERNEL, -1);
 		if (unlikely(!tsk->io_context))
 			return -ENOMEM;
 		tsk->io_context->ioprio = ioc->ioprio;
 	}
 #endif
 	return 0;
 }
 /*
  *	Helper to unshare the files of the current task.
  *	We don't want to expose copy_files internals to
  *	the exec layer of the kernel.
  */
 int unshare_files(void)
 {
 	struct files_struct *files  = current->files;
 	int rc;
 	BUG_ON(!files);
 	/* This can race but the race causes us to copy when we don't
 	   need to and drop the copy */
 	if(atomic_read(&files->count) == 1)
 	{
 		atomic_inc(&files->count);
 		return 0;
 	}
 	rc = copy_files(0, current);
 	if(rc)
 		current->files = files;
 	return rc;
 }
 EXPORT_SYMBOL(unshare_files);
 static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
 {
 	struct sighand_struct *sig;
 	if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
 		atomic_inc(&current->sighand->count);
 		return 0;
 	}
 	sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
 	rcu_assign_pointer(tsk->sighand, sig);
 	if (!sig)
 		return -ENOMEM;
 	atomic_set(&sig->count, 1);
 	memcpy(sig->action, current->sighand->action, sizeof(sig->action));
 	return 0;
 }
 void __cleanup_sighand(struct sighand_struct *sighand)
 {
 	if (atomic_dec_and_test(&sighand->count))
 		kmem_cache_free(sighand_cachep, sighand);
 }
 static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
 {
 	struct signal_struct *sig;
 	int ret;
 	if (clone_flags & CLONE_THREAD) {
 		atomic_inc(&current->signal->count);
 		atomic_inc(&current->signal->live);
 		return 0;
 	}
 	sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
 	tsk->signal = sig;
 	if (!sig)
 		return -ENOMEM;
 	ret = copy_thread_group_keys(tsk);
 	if (ret < 0) {
 		kmem_cache_free(signal_cachep, sig);
 		return ret;
 	}
 	atomic_set(&sig->count, 1);
 	atomic_set(&sig->live, 1);
 	init_waitqueue_head(&sig->wait_chldexit);
 	sig->flags = 0;
 	sig->group_exit_code = 0;
 	sig->group_exit_task = NULL;
 	sig->group_stop_count = 0;
 	sig->curr_target = NULL;
 	init_sigpending(&sig->shared_pending);
 	INIT_LIST_HEAD(&sig->posix_timers);
 	hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 	sig->it_real_incr.tv64 = 0;
 	sig->real_timer.function = it_real_fn;
 	sig->it_virt_expires = cputime_zero;
 	sig->it_virt_incr = cputime_zero;
 	sig->it_prof_expires = cputime_zero;
 	sig->it_prof_incr = cputime_zero;
 	sig->leader = 0;	/* session leadership doesn't inherit */
 	sig->tty_old_pgrp = NULL;
 	sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
 	sig->gtime = cputime_zero;
 	sig->cgtime = cputime_zero;
 	sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
 	sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
 	sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
 	sig->sum_sched_runtime = 0;
 	INIT_LIST_HEAD(&sig->cpu_timers[0]);
 	INIT_LIST_HEAD(&sig->cpu_timers[1]);
 	INIT_LIST_HEAD(&sig->cpu_timers[2]);
 	taskstats_tgid_init(sig);
 	task_lock(current->group_leader);
 	memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
 	task_unlock(current->group_leader);
 	if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
 		/*
 		 * New sole thread in the process gets an expiry time
 		 * of the whole CPU time limit.
 		 */
 		tsk->it_prof_expires =
 			secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
 	}
 	acct_init_pacct(&sig->pacct);
 	tty_audit_fork(sig);
 	return 0;
 }
 void __cleanup_signal(struct signal_struct *sig)
 {
 	exit_thread_group_keys(sig);
 	kmem_cache_free(signal_cachep, sig);
 }
 static void cleanup_signal(struct task_struct *tsk)
 {
 	struct signal_struct *sig = tsk->signal;
 	atomic_dec(&sig->live);
 	if (atomic_dec_and_test(&sig->count))
 		__cleanup_signal(sig);
 }
 static void copy_flags(unsigned long clone_flags, struct task_struct *p)
 {
 	unsigned long new_flags = p->flags;
 	new_flags &= ~PF_SUPERPRIV;
 	new_flags |= PF_FORKNOEXEC;
 	if (!(clone_flags & CLONE_PTRACE))
 		p->ptrace = 0;
 	p->flags = new_flags;
 	clear_freeze_flag(p);
 }
 asmlinkage long sys_set_tid_address(int __user *tidptr)
 {
 	current->clear_child_tid = tidptr;
 	return task_pid_vnr(current);
 }
 static void rt_mutex_init_task(struct task_struct *p)
 {
 	spin_lock_init(&p->pi_lock);
 #ifdef CONFIG_RT_MUTEXES
 	plist_head_init(&p->pi_waiters, &p->pi_lock);
 	p->pi_blocked_on = NULL;
 #endif
 }
 /*
  * This creates a new process as a copy of the old one,
  * but does not actually start it yet.
  *
  * It copies the registers, and all the appropriate
  * parts of the process environment (as per the clone
  * flags). The actual kick-off is left to the caller.
  */
 static struct task_struct *copy_process(unsigned long clone_flags,
 					unsigned long stack_start,
 					struct pt_regs *regs,
 					unsigned long stack_size,
 					int __user *child_tidptr,
 					struct pid *pid)
 {
 	int retval;
 	struct task_struct *p;
 	int cgroup_callbacks_done = 0;
 	if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
 		return ERR_PTR(-EINVAL);
 	/*
 	 * Thread groups must share signals as well, and detached threads
 	 * can only be started up within the thread group.
 	 */
 	if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
 		return ERR_PTR(-EINVAL);
 	/*
 	 * Shared signal handlers imply shared VM. By way of the above,
 	 * thread groups also imply shared VM. Blocking this case allows
 	 * for various simplifications in other code.
 	 */
 	if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
 		return ERR_PTR(-EINVAL);
 	retval = security_task_create(clone_flags);
 	if (retval)
 		goto fork_out;
 	retval = -ENOMEM;
 	p = dup_task_struct(current);
 	if (!p)
 		goto fork_out;
 	rt_mutex_init_task(p);
 #ifdef CONFIG_TRACE_IRQFLAGS
 	DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
 	DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
 #endif
 	retval = -EAGAIN;
 	if (atomic_read(&p->user->processes) >=
 			p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
 		if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
 		    p->user != current->nsproxy->user_ns->root_user)
 			goto bad_fork_free;
 	}
 	atomic_inc(&p->user->__count);
 	atomic_inc(&p->user->processes);
 	get_group_info(p->group_info);
 	/*
 	 * If multiple threads are within copy_process(), then this check
 	 * triggers too late. This doesn't hurt, the check is only there
 	 * to stop root fork bombs.
 	 */
 	if (nr_threads >= max_threads)
 		goto bad_fork_cleanup_count;
 	if (!try_module_get(task_thread_info(p)->exec_domain->module))
 		goto bad_fork_cleanup_count;
 	if (p->binfmt && !try_module_get(p->binfmt->module))
 		goto bad_fork_cleanup_put_domain;
 	p->did_exec = 0;
 	delayacct_tsk_init(p);	/* Must remain after dup_task_struct() */
 	copy_flags(clone_flags, p);
 	INIT_LIST_HEAD(&p->children);
 	INIT_LIST_HEAD(&p->sibling);
 #ifdef CONFIG_PREEMPT_RCU
 	p->rcu_read_lock_nesting = 0;
 	p->rcu_flipctr_idx = 0;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 	p->vfork_done = NULL;
 	spin_lock_init(&p->alloc_lock);
 	clear_tsk_thread_flag(p, TIF_SIGPENDING);
 	init_sigpending(&p->pending);
 	p->utime = cputime_zero;
 	p->stime = cputime_zero;
 	p->gtime = cputime_zero;
 	p->utimescaled = cputime_zero;
 	p->stimescaled = cputime_zero;
 	p->prev_utime = cputime_zero;
 	p->prev_stime = cputime_zero;
 #ifdef CONFIG_DETECT_SOFTLOCKUP
 	p->last_switch_count = 0;
 	p->last_switch_timestamp = 0;
 #endif
 #ifdef CONFIG_TASK_XACCT
 	p->rchar = 0;		/* I/O counter: bytes read */
 	p->wchar = 0;		/* I/O counter: bytes written */
 	p->syscr = 0;		/* I/O counter: read syscalls */
 	p->syscw = 0;		/* I/O counter: write syscalls */
 #endif
 	task_io_accounting_init(p);
 	acct_clear_integrals(p);
 	p->it_virt_expires = cputime_zero;
 	p->it_prof_expires = cputime_zero;
 	p->it_sched_expires = 0;
 	INIT_LIST_HEAD(&p->cpu_timers[0]);
 	INIT_LIST_HEAD(&p->cpu_timers[1]);
 	INIT_LIST_HEAD(&p->cpu_timers[2]);
 	p->lock_depth = -1;		/* -1 = no lock */
 	do_posix_clock_monotonic_gettime(&p->start_time);
 	p->real_start_time = p->start_time;
 	monotonic_to_bootbased(&p->real_start_time);
 #ifdef CONFIG_SECURITY
 	p->security = NULL;
 #endif
 	p->cap_bset = current->cap_bset;
 	p->io_context = NULL;
 	p->audit_context = NULL;
 	cgroup_fork(p);
 #ifdef CONFIG_NUMA
  	p->mempolicy = mpol_copy(p->mempolicy);
  	if (IS_ERR(p->mempolicy)) {
  		retval = PTR_ERR(p->mempolicy);
  		p->mempolicy = NULL;
  		goto bad_fork_cleanup_cgroup;
  	}
 	mpol_fix_fork_child_flag(p);
 #endif
 #ifdef CONFIG_TRACE_IRQFLAGS
 	p->irq_events = 0;
 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
 	p->hardirqs_enabled = 1;
 #else
 	p->hardirqs_enabled = 0;
 #endif
 	p->hardirq_enable_ip = 0;
 	p->hardirq_enable_event = 0;
 	p->hardirq_disable_ip = _THIS_IP_;
 	p->hardirq_disable_event = 0;
 	p->softirqs_enabled = 1;
 	p->softirq_enable_ip = _THIS_IP_;
 	p->softirq_enable_event = 0;
 	p->softirq_disable_ip = 0;
 	p->softirq_disable_event = 0;
 	p->hardirq_context = 0;
 	p->softirq_context = 0;
 #endif
 #ifdef CONFIG_LOCKDEP
 	p->lockdep_depth = 0; /* no locks held yet */
 	p->curr_chain_key = 0;
 	p->lockdep_recursion = 0;
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
 	p->blocked_on = NULL; /* not blocked yet */
 #endif
 	/* Perform scheduler related setup. Assign this task to a CPU. */
 	sched_fork(p, clone_flags);
 	if ((retval = security_task_alloc(p)))
 		goto bad_fork_cleanup_policy;
 	if ((retval = audit_alloc(p)))
 		goto bad_fork_cleanup_security;
 	/* copy all the process information */
 	if ((retval = copy_semundo(clone_flags, p)))
 		goto bad_fork_cleanup_audit;
 	if ((retval = copy_files(clone_flags, p)))
 		goto bad_fork_cleanup_semundo;
 	if ((retval = copy_fs(clone_flags, p)))
 		goto bad_fork_cleanup_files;
 	if ((retval = copy_sighand(clone_flags, p)))
 		goto bad_fork_cleanup_fs;
 	if ((retval = copy_signal(clone_flags, p)))
 		goto bad_fork_cleanup_sighand;
 	if ((retval = copy_mm(clone_flags, p)))
 		goto bad_fork_cleanup_signal;
 	if ((retval = copy_keys(clone_flags, p)))
 		goto bad_fork_cleanup_mm;
 	if ((retval = copy_namespaces(clone_flags, p)))
 		goto bad_fork_cleanup_keys;
 	if ((retval = copy_io(clone_flags, p)))
 		goto bad_fork_cleanup_namespaces;
 	retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
 	if (retval)
 		goto bad_fork_cleanup_io;
 	if (pid != &init_struct_pid) {
 		retval = -ENOMEM;
 		pid = alloc_pid(task_active_pid_ns(p));
 		if (!pid)
 			goto bad_fork_cleanup_io;
 		if (clone_flags & CLONE_NEWPID) {
 			retval = pid_ns_prepare_proc(task_active_pid_ns(p));
 			if (retval < 0)
 				goto bad_fork_free_pid;
 		}
 	}
 	p->pid = pid_nr(pid);
 	p->tgid = p->pid;
 	if (clone_flags & CLONE_THREAD)
 		p->tgid = current->tgid;
 	p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
 	/*
 	 * Clear TID on mm_release()?
 	 */
 	p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
 #ifdef CONFIG_FUTEX
 	p->robust_list = NULL;
 #ifdef CONFIG_COMPAT
 	p->compat_robust_list = NULL;
 #endif
 	INIT_LIST_HEAD(&p->pi_state_list);
 	p->pi_state_cache = NULL;
 #endif
 	/*
 	 * sigaltstack should be cleared when sharing the same VM
 	 */
 	if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
 		p->sas_ss_sp = p->sas_ss_size = 0;
 	/*
 	 * Syscall tracing should be turned off in the child regardless
 	 * of CLONE_PTRACE.
 	 */
 	clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
 #ifdef TIF_SYSCALL_EMU
 	clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
 #endif
 	clear_all_latency_tracing(p);
 	/* Our parent execution domain becomes current domain
 	   These must match for thread signalling to apply */
 	p->parent_exec_id = p->self_exec_id;
 	/* ok, now we should be set up.. */
 	p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
 	p->pdeath_signal = 0;
 	p->exit_state = 0;
 	/*
 	 * Ok, make it visible to the rest of the system.
 	 * We dont wake it up yet.
 	 */
 	p->group_leader = p;
 	INIT_LIST_HEAD(&p->thread_group);
 	INIT_LIST_HEAD(&p->ptrace_children);
 	INIT_LIST_HEAD(&p->ptrace_list);
 	/* Now that the task is set up, run cgroup callbacks if
 	 * necessary. We need to run them before the task is visible
 	 * on the tasklist. */
 	cgroup_fork_callbacks(p);
 	cgroup_callbacks_done = 1;
 	/* Need tasklist lock for parent etc handling! */
 	write_lock_irq(&tasklist_lock);
 	/*
 	 * The task hasn't been attached yet, so its cpus_allowed mask will
 	 * not be changed, nor will its assigned CPU.
 	 *
 	 * The cpus_allowed mask of the parent may have changed after it was
 	 * copied first time - so re-copy it here, then check the child's CPU
 	 * to ensure it is on a valid CPU (and if not, just force it back to
 	 * parent's CPU). This avoids alot of nasty races.
 	 */
 	p->cpus_allowed = current->cpus_allowed;
 	p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed;
 	if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
 			!cpu_online(task_cpu(p))))
 		set_task_cpu(p, smp_processor_id());
 	/* CLONE_PARENT re-uses the old parent */
 	if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
 		p->real_parent = current->real_parent;
 	else
 		p->real_parent = current;
 	p->parent = p->real_parent;
 	spin_lock(&current->sighand->siglock);
 	/*
 	 * Process group and session signals need to be delivered to just the
 	 * parent before the fork or both the parent and the child after the
 	 * fork. Restart if a signal comes in before we add the new process to
 	 * it's process group.
 	 * A fatal signal pending means that current will exit, so the new
 	 * thread can't slip out of an OOM kill (or normal SIGKILL).
  	 */
 	recalc_sigpending();
 	if (signal_pending(current)) {
 		spin_unlock(&current->sighand->siglock);
 		write_unlock_irq(&tasklist_lock);
 		retval = -ERESTARTNOINTR;
 		goto bad_fork_free_pid;
 	}
 	if (clone_flags & CLONE_THREAD) {
 		p->group_leader = current->group_leader;
 		list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
 		if (!cputime_eq(current->signal->it_virt_expires,
 				cputime_zero) ||
 		    !cputime_eq(current->signal->it_prof_expires,
 				cputime_zero) ||
 		    current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
 		    !list_empty(&current->signal->cpu_timers[0]) ||
 		    !list_empty(&current->signal->cpu_timers[1]) ||
 		    !list_empty(&current->signal->cpu_timers[2])) {
 			/*
 			 * Have child wake up on its first tick to check
 			 * for process CPU timers.
 			 */
 			p->it_prof_expires = jiffies_to_cputime(1);
 		}
 	}
 	if (likely(p->pid)) {
 		add_parent(p);
 		if (unlikely(p->ptrace & PT_PTRACED))
 			__ptrace_link(p, current->parent);
 		if (thread_group_leader(p)) {
 			if (clone_flags & CLONE_NEWPID)
 				p->nsproxy->pid_ns->child_reaper = p;
 			p->signal->leader_pid = pid;
 			p->signal->tty = current->signal->tty;
 			set_task_pgrp(p, task_pgrp_nr(current));
 			set_task_session(p, task_session_nr(current));
 			attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
 			attach_pid(p, PIDTYPE_SID, task_session(current));
 			list_add_tail_rcu(&p->tasks, &init_task.tasks);
 			__get_cpu_var(process_counts)++;
 		}
 		attach_pid(p, PIDTYPE_PID, pid);
 		nr_threads++;
 	}
 	total_forks++;
 	spin_unlock(&current->sighand->siglock);
 	write_unlock_irq(&tasklist_lock);
 	proc_fork_connector(p);
 	cgroup_post_fork(p);
 	return p;
 bad_fork_free_pid:
 	if (pid != &init_struct_pid)
 		free_pid(pid);
 bad_fork_cleanup_io:
 	put_io_context(p->io_context);
 bad_fork_cleanup_namespaces:
 	exit_task_namespaces(p);
 bad_fork_cleanup_keys:
 	exit_keys(p);
 bad_fork_cleanup_mm:
 	if (p->mm)
 		mmput(p->mm);
 bad_fork_cleanup_signal:
 	cleanup_signal(p);
 bad_fork_cleanup_sighand:
 	__cleanup_sighand(p->sighand);
 bad_fork_cleanup_fs:
 	exit_fs(p); /* blocking */
 bad_fork_cleanup_files:
 	exit_files(p); /* blocking */
 bad_fork_cleanup_semundo:
 	exit_sem(p);
 bad_fork_cleanup_audit:
 	audit_free(p);
 bad_fork_cleanup_security:
 	security_task_free(p);
 bad_fork_cleanup_policy:
 #ifdef CONFIG_NUMA
 	mpol_free(p->mempolicy);
 bad_fork_cleanup_cgroup:
 #endif
 	cgroup_exit(p, cgroup_callbacks_done);
 	delayacct_tsk_free(p);
 	if (p->binfmt)
 		module_put(p->binfmt->module);
 bad_fork_cleanup_put_domain:
 	module_put(task_thread_info(p)->exec_domain->module);
 bad_fork_cleanup_count:
 	put_group_info(p->group_info);
 	atomic_dec(&p->user->processes);
 	free_uid(p->user);
 bad_fork_free:
 	free_task(p);
 fork_out:
 	return ERR_PTR(retval);
 }
 noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
 {
 	memset(regs, 0, sizeof(struct pt_regs));
 	return regs;
 }
 struct task_struct * __cpuinit fork_idle(int cpu)
 {
 	struct task_struct *task;
 	struct pt_regs regs;
 	task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,
 				&init_struct_pid);
 	if (!IS_ERR(task))
 		init_idle(task, cpu);
 	return task;
 }
 static int fork_traceflag(unsigned clone_flags)
 {
 	if (clone_flags & CLONE_UNTRACED)
 		return 0;
 	else if (clone_flags & CLONE_VFORK) {
 		if (current->ptrace & PT_TRACE_VFORK)
 			return PTRACE_EVENT_VFORK;
 	} else if ((clone_flags & CSIGNAL) != SIGCHLD) {
 		if (current->ptrace & PT_TRACE_CLONE)
 			return PTRACE_EVENT_CLONE;
 	} else if (current->ptrace & PT_TRACE_FORK)
 		return PTRACE_EVENT_FORK;
 	return 0;
 }
 /*
  *  Ok, this is the main fork-routine.
  *
  * It copies the process, and if successful kick-starts
  * it and waits for it to finish using the VM if required.
  */
 long do_fork(unsigned long clone_flags,
 	      unsigned long stack_start,
 	      struct pt_regs *regs,
 	      unsigned long stack_size,
 	      int __user *parent_tidptr,
 	      int __user *child_tidptr)
 {
 	struct task_struct *p;
 	int trace = 0;
 	long nr;
 	/*
 	 * We hope to recycle these flags after 2.6.26
 	 */
 	if (unlikely(clone_flags & CLONE_STOPPED)) {
 		static int __read_mostly count = 100;
 		if (count > 0 && printk_ratelimit()) {
 			char comm[TASK_COMM_LEN];
 			count--;
 			printk(KERN_INFO "fork(): process `%s' used deprecated "
 					"clone flags 0x%lx\n",
 				get_task_comm(comm, current),
 				clone_flags & CLONE_STOPPED);
 		}
 	}
 	if (unlikely(current->ptrace)) {
 		trace = fork_traceflag (clone_flags);
 		if (trace)
 			clone_flags |= CLONE_PTRACE;
 	}
 	p = copy_process(clone_flags, stack_start, regs, stack_size,
 			child_tidptr, NULL);
 	/*
 	 * Do this prior waking up the new thread - the thread pointer
 	 * might get invalid after that point, if the thread exits quickly.
 	 */
 	if (!IS_ERR(p)) {
 		struct completion vfork;
 		nr = task_pid_vnr(p);
 		if (clone_flags & CLONE_PARENT_SETTID)
 			put_user(nr, parent_tidptr);
 		if (clone_flags & CLONE_VFORK) {
 			p->vfork_done = &vfork;
 			init_completion(&vfork);
 		}
 		if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
 			/*
 			 * We'll start up with an immediate SIGSTOP.
 			 */
 			sigaddset(&p->pending.signal, SIGSTOP);
 			set_tsk_thread_flag(p, TIF_SIGPENDING);
 		}
 		if (!(clone_flags & CLONE_STOPPED))
 			wake_up_new_task(p, clone_flags);
 		else
 			__set_task_state(p, TASK_STOPPED);
 		if (unlikely (trace)) {
 			current->ptrace_message = nr;
 			ptrace_notify ((trace << 8) | SIGTRAP);
 		}
 		if (clone_flags & CLONE_VFORK) {
 			freezer_do_not_count();
 			wait_for_completion(&vfork);
 			freezer_count();
 			if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
 				current->ptrace_message = nr;
 				ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
 			}
 		}
 	} else {
 		nr = PTR_ERR(p);
 	}
 	return nr;
 }
 #ifndef ARCH_MIN_MMSTRUCT_ALIGN
 #define ARCH_MIN_MMSTRUCT_ALIGN 0
 #endif
 static void sighand_ctor(struct kmem_cache *cachep, void *data)
 {
 	struct sighand_struct *sighand = data;
 	spin_lock_init(&sighand->siglock);
 	init_waitqueue_head(&sighand->signalfd_wqh);
 }
 void __init proc_caches_init(void)
 {
 	sighand_cachep = kmem_cache_create("sighand_cache",
 			sizeof(struct sighand_struct), 0,
 			SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,
 			sighand_ctor);
 	signal_cachep = kmem_cache_create("signal_cache",
 			sizeof(struct signal_struct), 0,
 			SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 	files_cachep = kmem_cache_create("files_cache",
 			sizeof(struct files_struct), 0,
 			SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 	fs_cachep = kmem_cache_create("fs_cache",
 			sizeof(struct fs_struct), 0,
 			SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 	vm_area_cachep = kmem_cache_create("vm_area_struct",
 			sizeof(struct vm_area_struct), 0,
 			SLAB_PANIC, NULL);
 	mm_cachep = kmem_cache_create("mm_struct",
 			sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
 			SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 }
 /*
  * Check constraints on flags passed to the unshare system call and
  * force unsharing of additional process context as appropriate.
  */
 static void check_unshare_flags(unsigned long *flags_ptr)
 {
 	/*
 	 * If unsharing a thread from a thread group, must also
 	 * unshare vm.
 	 */
 	if (*flags_ptr & CLONE_THREAD)
 		*flags_ptr |= CLONE_VM;
 	/*
 	 * If unsharing vm, must also unshare signal handlers.
 	 */
 	if (*flags_ptr & CLONE_VM)
 		*flags_ptr |= CLONE_SIGHAND;
 	/*
 	 * If unsharing signal handlers and the task was created
 	 * using CLONE_THREAD, then must unshare the thread
 	 */
 	if ((*flags_ptr & CLONE_SIGHAND) &&
 	    (atomic_read(&current->signal->count) > 1))
 		*flags_ptr |= CLONE_THREAD;
 	/*
 	 * If unsharing namespace, must also unshare filesystem information.
 	 */
 	if (*flags_ptr & CLONE_NEWNS)
 		*flags_ptr |= CLONE_FS;
 }
 /*
  * Unsharing of tasks created with CLONE_THREAD is not supported yet
  */
 static int unshare_thread(unsigned long unshare_flags)
 {
 	if (unshare_flags & CLONE_THREAD)
 		return -EINVAL;
 	return 0;
 }
 /*
  * Unshare the filesystem structure if it is being shared
  */
 static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)
 {
 	struct fs_struct *fs = current->fs;
 	if ((unshare_flags & CLONE_FS) &&
 	    (fs && atomic_read(&fs->count) > 1)) {
 		*new_fsp = __copy_fs_struct(current->fs);
 		if (!*new_fsp)
 			return -ENOMEM;
 	}
 	return 0;
 }
 /*
  * Unsharing of sighand is not supported yet
  */
 static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)
 {
 	struct sighand_struct *sigh = current->sighand;
 	if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)
 		return -EINVAL;
 	else
 		return 0;
 }
 /*
  * Unshare vm if it is being shared
  */
 static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)
 {
 	struct mm_struct *mm = current->mm;
 	if ((unshare_flags & CLONE_VM) &&
 	    (mm && atomic_read(&mm->mm_users) > 1)) {
 		return -EINVAL;
 	}
 	return 0;
 }
 /*
  * Unshare file descriptor table if it is being shared
  */
 static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)
 {
 	struct files_struct *fd = current->files;
 	int error = 0;
 	if ((unshare_flags & CLONE_FILES) &&
 	    (fd && atomic_read(&fd->count) > 1)) {
 		*new_fdp = dup_fd(fd, &error);
 		if (!*new_fdp)
 			return error;
 	}
 	return 0;
 }
 /*
  * Unsharing of semundo for tasks created with CLONE_SYSVSEM is not
  * supported yet
  */
 static int unshare_semundo(unsigned long unshare_flags, struct sem_undo_list **new_ulistp)
 {
 	if (unshare_flags & CLONE_SYSVSEM)
 		return -EINVAL;
 	return 0;
 }
 /*
  * unshare allows a process to 'unshare' part of the process
  * context which was originally shared using clone.  copy_*
  * functions used by do_fork() cannot be used here directly
  * because they modify an inactive task_struct that is being
  * constructed. Here we are modifying the current, active,
  * task_struct.
  */
 asmlinkage long sys_unshare(unsigned long unshare_flags)
 {
 	int err = 0;
 	struct fs_struct *fs, *new_fs = NULL;
 	struct sighand_struct *new_sigh = NULL;
 	struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;
 	struct files_struct *fd, *new_fd = NULL;
 	struct sem_undo_list *new_ulist = NULL;
 	struct nsproxy *new_nsproxy = NULL;
 	check_unshare_flags(&unshare_flags);
 	/* Return -EINVAL for all unsupported flags */
 	err = -EINVAL;
 	if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
 				CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
 				CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWUSER|
 				CLONE_NEWNET))
 		goto bad_unshare_out;
 	if ((err = unshare_thread(unshare_flags)))
 		goto bad_unshare_out;
 	if ((err = unshare_fs(unshare_flags, &new_fs)))
 		goto bad_unshare_cleanup_thread;
 	if ((err = unshare_sighand(unshare_flags, &new_sigh)))
 		goto bad_unshare_cleanup_fs;
 	if ((err = unshare_vm(unshare_flags, &new_mm)))
 		goto bad_unshare_cleanup_sigh;
 	if ((err = unshare_fd(unshare_flags, &new_fd)))
 		goto bad_unshare_cleanup_vm;
 	if ((err = unshare_semundo(unshare_flags, &new_ulist)))
 		goto bad_unshare_cleanup_fd;
 	if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,
 			new_fs)))
 		goto bad_unshare_cleanup_semundo;
 	if (new_fs ||  new_mm || new_fd || new_ulist || new_nsproxy) {
 		if (new_nsproxy) {
 			switch_task_namespaces(current, new_nsproxy);
 			new_nsproxy = NULL;
 		}
 		task_lock(current);
 		if (new_fs) {
 			fs = current->fs;
 			current->fs = new_fs;
 			new_fs = fs;
 		}
 		if (new_mm) {
 			mm = current->mm;
 			active_mm = current->active_mm;
 			current->mm = new_mm;
 			current->active_mm = new_mm;
 			activate_mm(active_mm, new_mm);
 			new_mm = mm;
 		}
 		if (new_fd) {
 			fd = current->files;
 			current->files = new_fd;
 			new_fd = fd;
 		}
 		task_unlock(current);
 	}
 	if (new_nsproxy)
 		put_nsproxy(new_nsproxy);
 bad_unshare_cleanup_semundo:
 bad_unshare_cleanup_fd:
 	if (new_fd)
 		put_files_struct(new_fd);
 bad_unshare_cleanup_vm:
 	if (new_mm)
 		mmput(new_mm);
 bad_unshare_cleanup_sigh:
 	if (new_sigh)
 		if (atomic_dec_and_test(&new_sigh->count))
 			kmem_cache_free(sighand_cachep, new_sigh);
 bad_unshare_cleanup_fs:
 	if (new_fs)
 		put_fs_struct(new_fs);
 bad_unshare_cleanup_thread:
 bad_unshare_out:
 	return err;
 }