~ubuntu-branches/ubuntu/vivid/aufs/vivid : revision 6

1

#! /bin/sh /usr/share/dpatch/dpatch-run

2

## 06_ubuntu.dpatch by Julian Andres Klode <juliank@ubuntu.com>

3

##

4

## DP: Fix problems with Ubuntu's kernel

5

6

@DPATCH@

7

diff -urNad aufs-0+20071211~/fs/aufs/cpup.c aufs-0+20071211/fs/aufs/cpup.c

8

--- aufs-0+20071211~/fs/aufs/cpup.c 2007-11-26 02:34:04.000000000 +0100

9

+++ aufs-0+20071211/fs/aufs/cpup.c 2007-12-11 19:18:51.000000000 +0100

10

@@ -119,7 +119,8 @@

11

12

/* keep the timestamps of the parent dir when cpup */

13

void au_dtime_store(struct au_dtime *dt, struct dentry *dentry,

14

- aufs_bindex_t bindex, struct dentry *h_dentry)

15

+ aufs_bindex_t bindex, struct dentry *h_dentry,

16

+ struct vfsmount *h_mnt)

17

{

18

struct inode *inode;

19

20

@@ -128,6 +129,7 @@

21

22

dt->dt_dentry = dentry;

23

dt->dt_h_dentry = h_dentry;

24

+ dt->dt_h_mnt = h_mnt;

25

dt->dt_bindex = bindex;

26

inode = h_dentry->d_inode;

27

dt->dt_atime = inode->i_atime;

28

@@ -156,17 +158,20 @@

29

parent = dget_parent(dt->dt_dentry);

30

vfsub_ign_hinode(&vargs, IN_ATTRIB,

31

itohi(parent->d_inode, dt->dt_bindex));

32

- err = vfsub_notify_change(dt->dt_h_dentry, &attr, &vargs);

33

+ err = vfsub_notify_change(dt->dt_h_dentry, dt->dt_h_mnt, &attr,

34

+ &vargs);

35

dput(parent);

36

} else

37

- err = vfsub_notify_change(dt->dt_h_dentry, &attr, &vargs);

38

+ err = vfsub_notify_change(dt->dt_h_dentry, dt->dt_h_mnt, &attr,

39

+ &vargs);

40

if (unlikely(err))

41

AuWarn("restoring timestamps failed(%d). ignored\n", err);

42

}

43

44

/* ---------------------------------------------------------------------- */

45

46

-static int cpup_iattr(struct dentry *h_dst, struct dentry *h_src, int dlgt)

47

+static int cpup_iattr(struct dentry *h_dst, struct dentry *h_src,

48

+ struct vfsmount *h_dst_mnt, int dlgt)

49

{

50

int err, sbits;

51

struct iattr ia;

52

@@ -190,7 +195,7 @@

53

sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));

54

55

vfsub_args_init(&vargs, NULL, dlgt, /*force_unlink*/0);

56

- err = vfsub_notify_change(h_dst, &ia, &vargs);

57

+ err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);

58

//if (LktrCond) err = -1;

59

60

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)

61

@@ -198,7 +203,7 @@

62

if (!err && sbits && au_test_nfs(h_dst->d_sb)) {

63

ia.ia_valid = ATTR_FORCE | ATTR_MODE;

64

ia.ia_mode = h_isrc->i_mode;

65

- err = vfsub_notify_change(h_dst, &ia, &vargs);

66

+ err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);

67

}

68

#endif

69

if (!err)

70

@@ -269,7 +274,8 @@

71

72

/* stop updating while we copyup */

73

IMustLock(hidden[SRC].dentry->d_inode);

74

- err = au_copy_file(hidden[DST].file, hidden[SRC].file, len, sb);

75

+ err = au_copy_file(hidden[DST].file, hidden[SRC].file, len, sb,

76

+ sbr_mnt(sb, bdst));

77

78

out_dst_file:

79

fput(hidden[DST].file);

80

@@ -295,6 +301,7 @@

81

char *sym;

82

mm_segment_t old_fs;

83

struct super_block *sb;

84

+ struct vfsmount *h_mnt;

85

struct vfsub_args vargs;

86

const int do_dt = flags->dtime;

87

88

@@ -304,6 +311,7 @@

89

sb = dentry->d_sb;

90

AuDebugOn(bdst >= bsrc || au_test_ro(sb, bdst, NULL));

91

/* bsrc branch can be ro/rw. */

92

+ h_mnt = sbr_mnt(sb, bdst);

93

94

h_src = au_h_dptr_i(dentry, bsrc);

95

AuDebugOn(!h_src);

96

@@ -320,7 +328,7 @@

97

IMustLock(h_dir);

98

99

if (do_dt)

100

- au_dtime_store(&dt, parent, bdst, h_parent);

101

+ au_dtime_store(&dt, parent, bdst, h_parent, h_mnt);

102

103

mode = h_inode->i_mode;

104

switch (mode & S_IFMT) {

105

@@ -341,7 +349,8 @@

106

if (unlikely(err)) {

107

int rerr;

108

vfsub_args_init(&vargs, NULL, dlgt, 0);

109

- rerr = vfsub_unlink(h_dir, h_dst, &vargs);

110

+ rerr = vfsub_unlink(h_dir, h_dst, h_mnt,

111

+ &vargs);

112

if (rerr) {

113

AuIOErr("failed unlinking cpup-ed %.*s"

114

"(%d, %d)\n",

115

@@ -352,7 +361,7 @@

116

}

117

break;

118

case S_IFDIR:

119

- err = vfsub_mkdir(h_dir, h_dst, mode, dlgt);

120

+ err = vfsub_mkdir(h_dir, h_dst, h_mnt, mode, dlgt);

121

//if (LktrCond) {vfs_rmdir(h_dir, h_dst); err = -1;}

122

if (!err) {

123

/* setattr case: dir is not locked */

124

@@ -376,7 +385,8 @@

125

set_fs(old_fs);

126

if (symlen > 0) {

127

sym[symlen] = 0;

128

- err = vfsub_symlink(h_dir, h_dst, sym, mode, dlgt);

129

+ err = vfsub_symlink(h_dir, h_dst, h_mnt, sym, mode,

130

+ dlgt);

131

//if (LktrCond)

132

//{vfs_unlink(h_dir, h_dst); err = -1;}

133

}

134

@@ -388,7 +398,8 @@

135

/*FALLTHROUGH*/

136

case S_IFIFO:

137

case S_IFSOCK:

138

- err = vfsub_mknod(h_dir, h_dst, mode, h_inode->i_rdev, dlgt);

139

+ err = vfsub_mknod(h_dir, h_dst, h_mnt, mode, h_inode->i_rdev,

140

+ dlgt);

141

//if (LktrCond) {vfs_unlink(h_dir, h_dst); err = -1;}

142

break;

143

default:

144

@@ -419,6 +430,7 @@

145

struct au_dtime dt;

146

struct vfsub_args vargs;

147

struct aufs_sbinfo *sbinfo;

148

+ struct vfsmount *h_mnt;

149

150

LKTRTrace("%.*s, i%lu, bdst %d, bsrc %d, len %Ld, dtime %u\n",

151

AuDLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,

152

@@ -438,6 +450,7 @@

153

dir = parent->d_inode;

154

155

sbinfo = stosi(sb);

156

+ h_mnt = sbr_mnt(sb, bdst);

157

dlgt = au_need_dlgt(sb);

158

dst_inode = au_h_iptr_i(inode, bdst);

159

if (unlikely(dst_inode)) {

160

@@ -454,7 +467,8 @@

161

if (IS_ERR(h_src))

162

goto out;

163

AuDebugOn(!h_src->d_inode);

164

- err = vfsub_link(h_src, h_dir, h_dst, dlgt);

165

+ err = vfsub_link(h_src, h_mnt, h_dir, h_dst, h_mnt,

166

+ dlgt);

167

dput(h_src);

168

goto out;

169

} else

170

@@ -471,7 +485,7 @@

171

vfsub_i_lock_nested(dst_inode, AuLsc_I_CHILD2);

172

173

//todo: test dlgt

174

- err = cpup_iattr(h_dst, h_src, dlgt);

175

+ err = cpup_iattr(h_dst, h_src, h_mnt, dlgt);

176

//if (LktrCond) err = -1;

177

#if 0 // xattr

178

if (0 && !err)

179

@@ -494,12 +508,12 @@

180

181

/* revert */

182

vfsub_i_unlock(dst_inode);

183

- au_dtime_store(&dt, parent, bdst, h_parent);

184

+ au_dtime_store(&dt, parent, bdst, h_parent, h_mnt);

185

vfsub_args_init(&vargs, NULL, dlgt, 0);

186

if (!isdir)

187

- rerr = vfsub_unlink(h_dir, h_dst, &vargs);

188

+ rerr = vfsub_unlink(h_dir, h_dst, h_mnt, &vargs);

189

else

190

- rerr = vfsub_rmdir(h_dir, h_dst, &vargs);

191

+ rerr = vfsub_rmdir(h_dir, h_dst, h_mnt, &vargs);

192

//rerr = -1;

193

au_dtime_revert(&dt);

194

if (rerr) {

195

@@ -671,6 +685,7 @@

196

struct au_dtime dt;

197

struct aufs_dinfo *dinfo;

198

aufs_bindex_t bstart;

199

+ struct vfsmount *h_mnt;

200

struct vfsub_args vargs;

201

struct aufs_ndx ndx = {

202

.nd = NULL,

203

@@ -701,7 +716,8 @@

204

if (IS_ERR(wh_dentry))

205

goto out;

206

207

- au_dtime_store(&dt, parent, bdst, h_parent);

208

+ h_mnt = sbr_mnt(sb, bdst);

209

+ au_dtime_store(&dt, parent, bdst, h_parent, h_mnt);

210

dinfo = dtodi(dentry);

211

bstart = dinfo->di_bstart;

212

h_dentry_bdst = dinfo->di_hdentry[0 + bdst].hd_dentry;

213

@@ -727,7 +743,7 @@

214

/* dget first to force sillyrename on nfs */

215

dget(wh_dentry);

216

vfsub_args_init(&vargs, NULL, ndx.dlgt, 0);

217

- err = vfsub_unlink(h_dir, wh_dentry, &vargs);

218

+ err = vfsub_unlink(h_dir, wh_dentry, h_mnt, &vargs);

219

//if (LktrCond) err = -1;

220

if (unlikely(err)) {

221

AuIOErr("failed remove copied-up tmp file %.*s(%d)\n",

222

diff -urNad aufs-0+20071211~/fs/aufs/cpup.h aufs-0+20071211/fs/aufs/cpup.h

223

--- aufs-0+20071211~/fs/aufs/cpup.h 2007-11-12 02:39:39.000000000 +0100

224

+++ aufs-0+20071211/fs/aufs/cpup.h 2007-12-11 19:18:51.000000000 +0100

225

@@ -75,11 +75,13 @@

226

/* keep timestamps when copyup */

227

struct au_dtime {

228

struct dentry *dt_dentry, *dt_h_dentry;

229

+ struct vfsmount *dt_h_mnt;

230

aufs_bindex_t dt_bindex;

231

struct timespec dt_atime, dt_mtime;

232

};

233

void au_dtime_store(struct au_dtime *dt, struct dentry *dentry,

234

- aufs_bindex_t bindex, struct dentry *h_dentry);

235

+ aufs_bindex_t bindex, struct dentry *h_dentry,

236

+ struct vfsmount *h_mnt);

237

void au_dtime_revert(struct au_dtime *dt);

238

239

#endif /* __KERNEL__ */

240

diff -urNad aufs-0+20071211~/fs/aufs/i_op.c aufs-0+20071211/fs/aufs/i_op.c

241

--- aufs-0+20071211~/fs/aufs/i_op.c 2007-11-26 02:34:25.000000000 +0100

242

+++ aufs-0+20071211/fs/aufs/i_op.c 2007-12-11 19:18:51.000000000 +0100

243

@@ -531,7 +531,7 @@

244

vfsub_ign_hinode(&vargs, events, itohi(dir, bcpup));

245

}

246

HiLock(bcpup);

247

- err = vfsub_notify_change(h_dentry, ia, &vargs);

248

+ err = vfsub_notify_change(h_dentry, sbr_mnt(sb, bcpup), ia, &vargs);

249

//err = -1;

250

if (!err)

251

au_cpup_attr_changeable(inode);

252

diff -urNad aufs-0+20071211~/fs/aufs/i_op_add.c aufs-0+20071211/fs/aufs/i_op_add.c

253

--- aufs-0+20071211~/fs/aufs/i_op_add.c 2007-12-10 02:19:07.000000000 +0100

254

+++ aufs-0+20071211/fs/aufs/i_op_add.c 2007-12-11 19:18:51.000000000 +0100

255

@@ -27,7 +27,7 @@

256

* if it failed, re-create the removed whiteout.

257

*/

258

static int epilog(struct inode *dir, struct dentry *wh_dentry,

259

- struct dentry *dentry)

260

+ struct vfsmount *h_mnt, struct dentry *dentry)

261

{

262

int err, rerr;

263

aufs_bindex_t bwh;

264

@@ -42,7 +42,7 @@

265

h_dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */

266

IMustLock(h_dir);

267

bwh = dbwh(dentry);

268

- err = au_unlink_wh_dentry(h_dir, wh_dentry, dentry, dir,

269

+ err = au_unlink_wh_dentry(h_dir, wh_dentry, h_mnt, dentry, dir,

270

/*dlgt*/0);

271

//err = -1;

272

if (unlikely(err))

273

@@ -120,7 +120,8 @@

274

h_dir = h_parent->d_inode;

275

hdir_lock(h_dir, dir, bcpup);

276

if (dt)

277

- au_dtime_store(dt, parent, bcpup, h_parent);

278

+ au_dtime_store(dt, parent, bcpup, h_parent,

279

+ sbr_mnt(parent->d_sb, bcpup));

280

wh_dentry = NULL;

281

if (/* bcpup != bstart || */ bcpup != dbwh(dentry))

282

goto out; /* success */

283

@@ -168,6 +169,7 @@

284

struct au_dtime dt;

285

struct vfsub_args vargs;

286

struct super_block *sb;

287

+ struct vfsmount *h_mnt;

288

struct au_wr_dir_args wr_dir_args = {

289

.force_btgt = -1,

290

.add_entry = 1,

291

@@ -194,6 +196,7 @@

292

IMustLock(h_dir);

293

sb = dir->i_sb;

294

dlgt = au_need_dlgt(sb);

295

+ h_mnt = sbr_mnt(sb, dbstart(dentry));

296

297

#if 1 // partial testing

298

switch (arg->type) {

299

@@ -203,11 +206,11 @@

300

arg->u.c.nd, au_nfsmnt(sb, dbstart(dentry)));

301

break;

302

case Symlink:

303

- err = vfsub_symlink(h_dir, h_dentry,

304

+ err = vfsub_symlink(h_dir, h_dentry, h_mnt,

305

arg->u.s.symname, S_IALLUGO, dlgt);

306

break;

307

case Mknod:

308

- err = vfsub_mknod(h_dir, h_dentry,

309

+ err = vfsub_mknod(h_dir, h_dentry, h_mnt,

310

arg->u.m.mode, arg->u.m.dev, dlgt);

311

break;

312

default:

313

@@ -217,14 +220,14 @@

314

err = -1;

315

#endif

316

if (!err)

317

- err = epilog(dir, wh_dentry, dentry);

318

+ err = epilog(dir, wh_dentry, h_mnt, dentry);

319

//err = -1;

320

321

/* revert */

322

if (unlikely(err && h_dentry->d_inode)) {

323

int rerr;

324

vfsub_args_init(&vargs, NULL, dlgt, 0);

325

- rerr = vfsub_unlink(h_dir, h_dentry, &vargs);

326

+ rerr = vfsub_unlink(h_dir, h_dentry, h_mnt, &vargs);

327

//rerr = -1;

328

if (rerr) {

329

AuIOErr("%.*s revert failure(%d, %d)\n",

330

@@ -345,6 +348,7 @@

331

aufs_bindex_t bstart;

332

struct super_block *sb;

333

struct au_cpup_flags cflags;

334

+ struct vfsmount *h_mnt;

335

336

AuTraceEnter();

337

338

@@ -354,8 +358,11 @@

339

h_inode = h_dentry->d_inode;

340

bstart = ibstart(inode);

341

h_dst_inode = NULL;

342

- if (bstart <= a->bdst)

343

+ h_mnt = NULL;

344

+ if (bstart <= a->bdst) {

345

h_dst_inode = au_h_iptr_i(inode, a->bdst);

346

+ h_mnt = sbr_mnt(sb, a->bdst);

347

+ }

348

349

if (!h_dst_inode || !h_dst_inode->i_nlink) {

350

/* copyup src_dentry as the name of dentry. */

351

@@ -373,8 +380,8 @@

352

/* the inode of src_dentry already exists on a.bdst branch */

353

h_dentry = d_find_alias(h_dst_inode);

354

if (h_dentry) {

355

- err = vfsub_link(h_dentry, a->h_dir,

356

- a->h_dentry, a->dlgt);

357

+ err = vfsub_link(h_dentry, h_mnt, a->h_dir, a->h_dentry,

358

+ h_mnt, a->dlgt);

359

dput(h_dentry);

360

} else {

361

AuIOErr("no dentry found for i%lu on b%d\n",

362

@@ -398,6 +405,7 @@

363

struct au_dtime dt;

364

struct link_arg a;

365

struct super_block *sb;

366

+ struct vfsmount *h_mnt;

367

struct vfsub_args vargs;

368

struct au_wr_dir_args wr_dir_args = {

369

//.force_btgt = -1,

370

@@ -441,6 +449,7 @@

371

a.bsrc = dbstart(src_dentry);

372

a.bdst = dbstart(dentry);

373

h_src_dentry = au_h_dptr(src_dentry);

374

+ h_mnt = sbr_mnt(sb, a.bdst);

375

if (unlikely(!AuFlag(stosi(sb), f_plink))) {

376

/*

377

* copyup src_dentry to the branch we process,

378

@@ -453,8 +462,8 @@

379

err = cpup_before_link(src_dentry, dir, &a);

380

if (!err) {

381

h_src_dentry = au_h_dptr(src_dentry);

382

- err = vfsub_link(h_src_dentry, a.h_dir,

383

- a.h_dentry, a.dlgt);

384

+ err = vfsub_link(h_src_dentry, h_mnt, a.h_dir,

385

+ a.h_dentry, h_mnt, a.dlgt);

386

//err = -1;

387

}

388

} else {

389

@@ -463,15 +472,15 @@

390

err = cpup_or_link(src_dentry, &a);

391

else {

392

h_src_dentry = au_h_dptr(src_dentry);

393

- err = vfsub_link(h_src_dentry, a.h_dir,

394

- a.h_dentry, a.dlgt);

395

+ err = vfsub_link(h_src_dentry, h_mnt, a.h_dir,

396

+ a.h_dentry, h_mnt, a.dlgt);

397

//err = -1;

398

}

399

}

400

if (unlikely(err))

401

goto out_unlock;

402

if (wh_dentry) {

403

- err = au_unlink_wh_dentry(a.h_dir, wh_dentry, dentry,

404

+ err = au_unlink_wh_dentry(a.h_dir, wh_dentry, h_mnt, dentry,

405

dir, /*dlgt*/0);

406

//err = -1;

407

if (unlikely(err))

408

@@ -542,7 +551,7 @@

409

}

410

#endif

411

vfsub_args_init(&vargs, NULL, a.dlgt, 0);

412

- rerr = vfsub_unlink(a.h_dir, a.h_dentry, &vargs);

413

+ rerr = vfsub_unlink(a.h_dir, a.h_dentry, h_mnt, &vargs);

414

//rerr = -1;

415

if (!rerr)

416

goto out_dt;

417

@@ -577,6 +586,7 @@

418

struct au_dtime dt;

419

aufs_bindex_t bindex;

420

struct super_block *sb;

421

+ struct vfsmount *h_mnt;

422

struct vfsub_args vargs;

423

struct au_wr_dir_args wr_dir_args = {

424

.force_btgt = -1,

425

@@ -606,8 +616,9 @@

426

h_dir = h_parent->d_inode;

427

IMustLock(h_dir);

428

dlgt = au_need_dlgt(sb);

429

+ h_mnt = sbr_mnt(sb, bindex);

430

431

- err = vfsub_mkdir(h_dir, h_dentry, mode, dlgt);

432

+ err = vfsub_mkdir(h_dir, h_dentry, h_mnt, mode, dlgt);

433

//err = -1;

434

if (unlikely(err))

435

goto out_unlock;

436

@@ -627,7 +638,7 @@

437

diropq = 1;

438

}

439

440

- err = epilog(dir, wh_dentry, dentry);

441

+ err = epilog(dir, wh_dentry, h_mnt, dentry);

442

//err = -1;

443

if (!err) {

444

dir->i_nlink++;

445

@@ -651,7 +662,7 @@

446

out_dir:

447

LKTRLabel(revert dir);

448

vfsub_args_init(&vargs, NULL, dlgt, 0);

449

- rerr = vfsub_rmdir(h_dir, h_dentry, &vargs);

450

+ rerr = vfsub_rmdir(h_dir, h_dentry, h_mnt, &vargs);

451

//rerr = -1;

452

if (rerr) {

453

AuIOErr("%.*s reverting dir failed(%d, %d)\n",

454

diff -urNad aufs-0+20071211~/fs/aufs/i_op_del.c aufs-0+20071211/fs/aufs/i_op_del.c

455

--- aufs-0+20071211~/fs/aufs/i_op_del.c 2007-11-19 02:07:10.000000000 +0100

456

+++ aufs-0+20071211/fs/aufs/i_op_del.c 2007-12-11 19:18:51.000000000 +0100

457

@@ -122,7 +122,8 @@

458

h_parent = au_h_dptr_i(parent, *bcpup);

459

h_dir = h_parent->d_inode;

460

hdir_lock(h_dir, dir, *bcpup);

461

- au_dtime_store(dt, parent, *bcpup, h_parent);

462

+ au_dtime_store(dt, parent, *bcpup, h_parent,

463

+ sbr_mnt(dentry->d_sb, *bcpup));

464

wh_dentry = NULL;

465

if (!need_wh)

466

goto out; /* success, no need to create whiteout */

467

@@ -212,16 +213,17 @@

468

unsigned int dlgt:1;

469

};

470

471

-static int do_revert(int err, struct dentry *wh_dentry, struct dentry *dentry,

472

- aufs_bindex_t bwh, struct au_dtime *dt,

473

- struct revert_flags *flags)

474

+static int do_revert(int err, struct dentry *wh_dentry, struct vfsmount *h_mnt,

475

+ struct dentry *dentry, aufs_bindex_t bwh,

476

+ struct au_dtime *dt, struct revert_flags *flags)

477

{

478

int rerr;

479

struct inode *dir;

480

481

dir = wh_dentry->d_parent->d_inode; /* dir inode is locked */

482

IMustLock(dir);

483

- rerr = au_unlink_wh_dentry(dir, wh_dentry, dentry, dir, !!flags->dlgt);

484

+ rerr = au_unlink_wh_dentry(dir, wh_dentry, h_mnt, dentry, dir,

485

+ !!flags->dlgt);

486

//rerr = -1;

487

if (!rerr) {

488

set_dbwh(dentry, bwh);

489

@@ -244,6 +246,7 @@

490

struct au_dtime dt;

491

aufs_bindex_t bwh, bindex, bstart;

492

struct super_block *sb;

493

+ struct vfsmount *h_mnt;

494

struct vfsub_args vargs;

495

496

LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));

497

@@ -270,12 +273,13 @@

498

dlgt = au_need_dlgt(sb);

499

h_dentry = au_h_dptr(dentry);

500

dget(h_dentry);

501

+ h_mnt = sbr_mnt(sb, dbstart(dentry));

502

503

if (bindex == bstart) {

504

vfsub_args_init(&vargs, NULL, dlgt, 0);

505

h_dir = h_dentry->d_parent->d_inode; /* dir inode is locked */

506

IMustLock(h_dir);

507

- err = vfsub_unlink(h_dir, h_dentry, &vargs);

508

+ err = vfsub_unlink(h_dir, h_dentry, h_mnt, &vargs);

509

//err = -1;

510

} else {

511

/* dir inode is locked */

512

@@ -308,7 +312,8 @@

513

struct revert_flags rev_flags = {

514

.dlgt = dlgt

515

};

516

- rerr = do_revert(err, wh_dentry, dentry, bwh, &dt, &rev_flags);

517

+ rerr = do_revert(err, wh_dentry, h_mnt, dentry, bwh, &dt,

518

+ &rev_flags);

519

if (rerr)

520

err = rerr;

521

}

522

@@ -334,6 +339,7 @@

523

struct rmdir_whtmp_args *args;

524

struct aufs_nhash *whlist;

525

struct super_block *sb;

526

+ struct vfsmount *h_mnt;

527

528

LKTRTrace("i%lu, %.*s\n", dir->i_ino, AuDLNPair(dentry));

529

IMustLock(dir);

530

@@ -372,6 +378,7 @@

531

532

h_dentry = au_h_dptr(dentry);

533

dget(h_dentry);

534

+ h_mnt = sbr_mnt(dentry->d_sb, dbstart(dentry));

535

536

rmdir_later = 0;

537

if (bindex == bstart) {

538

@@ -418,7 +425,8 @@

539

struct revert_flags rev_flags = {

540

.dlgt = au_need_dlgt(sb)

541

};

542

- rerr = do_revert(err, wh_dentry, dentry, bwh, &dt, &rev_flags);

543

+ rerr = do_revert(err, wh_dentry, h_mnt, dentry, bwh, &dt,

544

+ &rev_flags);

545

if (rerr)

546

err = rerr;

547

}

548

diff -urNad aufs-0+20071211~/fs/aufs/i_op_ren.c aufs-0+20071211/fs/aufs/i_op_ren.c

549

--- aufs-0+20071211~/fs/aufs/i_op_ren.c 2007-11-19 02:09:25.000000000 +0100

550

+++ aufs-0+20071211/fs/aufs/i_op_ren.c 2007-12-11 19:18:51.000000000 +0100

551

@@ -26,6 +26,7 @@

552

struct aufs_nhash whlist;

553

aufs_bindex_t btgt, bstart[2];

554

struct super_block *sb;

555

+ struct vfsmount *h_mnt;

556

557

unsigned int isdir:1;

558

unsigned int issamedir:1;

559

@@ -146,8 +147,9 @@

560

if (unlikely(a->udba && a->isdir))

561

vfsub_ign_hinode(&vargs, IN_MOVE_SELF,

562

itohi(src_dentry->d_inode, a->btgt));

563

- err = vfsub_rename(h_dir[SRC], au_h_dptr(src_dentry),

564

- h_dir[DST], a->h_dentry[DST], &vargs);

565

+ err = vfsub_rename(h_dir[SRC], au_h_dptr(src_dentry), a->h_mnt,

566

+ h_dir[DST], a->h_dentry[DST], a->h_mnt,

567

+ &vargs);

568

//err = -1;

569

} else {

570

bycpup = 1;

571

@@ -185,7 +187,7 @@

572

573

/* remove whiteout for dentry */

574

if (wh_dentry[DST]) {

575

- err = au_unlink_wh_dentry(h_dir[DST], wh_dentry[DST],

576

+ err = au_unlink_wh_dentry(h_dir[DST], wh_dentry[DST], a->h_mnt,

577

dentry, dir, /*dlgt*/0);

578

//err = -1;

579

if (unlikely(err))

580

@@ -254,8 +256,8 @@

581

vfsub_ign_hinode(&vargs, IN_MOVE_SELF,

582

itohi(src_dentry->d_inode, a->btgt));

583

rerr = vfsub_rename

584

- (h_dir[DST], au_h_dptr_i(src_dentry, a->btgt),

585

- h_dir[SRC], d, &vargs);

586

+ (h_dir[DST], au_h_dptr_i(src_dentry, a->btgt), a->h_mnt,

587

+ h_dir[SRC], d, a->h_mnt, &vargs);

588

//rerr = -1;

589

d_drop(d);

590

dput(d);

591

@@ -264,7 +266,8 @@

592

RevertFailure("rename %.*s", AuDLNPair(src_dentry));

593

} else {

594

vfsub_args_init(&vargs, NULL, a->dlgt, 0);

595

- rerr = vfsub_unlink(h_dir[DST], a->h_dentry[DST], &vargs);

596

+ rerr = vfsub_unlink(h_dir[DST], a->h_dentry[DST], a->h_mnt,

597

+ &vargs);

598

//rerr = -1;

599

set_h_dptr(src_dentry, a->btgt, NULL);

600

set_dbstart(src_dentry, a->bstart[SRC]);

601

@@ -294,7 +297,8 @@

602

if (unlikely(0 && a->udba && a->isdir))

603

vfsub_ign_hinode(&vargs, IN_MOVE_SELF,

604

itohi(dentry->d_inode, a->btgt));

605

- rerr = vfsub_rename(h_dir[DST], h_dst, h_dir[DST], d, &vargs);

606

+ rerr = vfsub_rename(h_dir[DST], h_dst, a->h_mnt, h_dir[DST], d,

607

+ a->h_mnt, &vargs);

608

//rerr = -1;

609

d_drop(d);

610

dput(d);

611

@@ -311,7 +315,7 @@

612

out_whsrc:

613

if (wh_dentry[SRC]) {

614

LKTRLabel(here);

615

- rerr = au_unlink_wh_dentry(h_dir[SRC], wh_dentry[SRC],

616

+ rerr = au_unlink_wh_dentry(h_dir[SRC], wh_dentry[SRC], a->h_mnt,

617

src_dentry, src_dir, /*dlgt*/0);

618

//rerr = -1;

619

if (rerr)

620

@@ -531,6 +535,7 @@

621

goto out_children;

622

}

623

624

+ p->a.h_mnt = sbr_mnt(p->a.sb, p->a.btgt);

625

p->a.h_parent[SRC] = au_h_dptr_i(p->a.parent[SRC], p->a.btgt);

626

p->a.h_parent[DST] = au_h_dptr_i(p->a.parent[DST], p->a.btgt);

627

dirs[0] = src_dir;

628

@@ -539,18 +544,18 @@

629

630

/* store timestamps to be revertible */

631

au_dtime_store(p->dt[PARENT] + SRC, p->a.parent[SRC], p->a.btgt,

632

- p->a.h_parent[SRC]);

633

+ p->a.h_parent[SRC], p->a.h_mnt);

634

if (!p->a.issamedir)

635

au_dtime_store(p->dt[PARENT] + DST, p->a.parent[DST], p->a.btgt,

636

- p->a.h_parent[DST]);

637

+ p->a.h_parent[DST], p->a.h_mnt);

638

do_dt_dstdir = 0;

639

if (p->a.isdir) {

640

au_dtime_store(p->dt[CHILD] + SRC, src_dentry, p->a.btgt,

641

- p->a.h_dentry[SRC]);

642

+ p->a.h_dentry[SRC], p->a.h_mnt);

643

if (p->a.h_dentry[DST]->d_inode) {

644

do_dt_dstdir = 1;

645

au_dtime_store(p->dt[CHILD] + DST, dentry, p->a.btgt,

646

- p->a.h_dentry[DST]);

647

+ p->a.h_dentry[DST], p->a.h_mnt);

648

}

649

}

650

651

diff -urNad aufs-0+20071211~/fs/aufs/misc.c aufs-0+20071211/fs/aufs/misc.c

652

--- aufs-0+20071211~/fs/aufs/misc.c 2007-11-12 02:40:06.000000000 +0100

653

+++ aufs-0+20071211/fs/aufs/misc.c 2007-12-11 19:18:51.000000000 +0100

654

@@ -154,7 +154,7 @@

655

/* ---------------------------------------------------------------------- */

656

657

int au_copy_file(struct file *dst, struct file *src, loff_t len,

658

- struct super_block *sb)

659

+ struct super_block *sb, struct vfsmount *dst_mnt)

660

{

661

int err, all_zero;

662

unsigned long blksize;

663

@@ -268,7 +268,7 @@

664

ia->ia_valid = ATTR_SIZE | ATTR_FILE;

665

ia->ia_file = dst;

666

vfsub_i_lock_nested(h_i, AuLsc_I_CHILD2);

667

- err = vfsub_notify_change(h_d, ia, &vargs);

668

+ err = vfsub_notify_change(h_d, dst_mnt, ia, &vargs);

669

vfsub_i_unlock(h_i);

670

}

671

}

672

diff -urNad aufs-0+20071211~/fs/aufs/misc.h aufs-0+20071211/fs/aufs/misc.h

673

--- aufs-0+20071211~/fs/aufs/misc.h 2007-11-12 02:40:06.000000000 +0100

674

+++ aufs-0+20071211/fs/aufs/misc.h 2007-12-11 19:18:51.000000000 +0100

675

@@ -201,7 +201,7 @@

676

int dlgt, struct nameidata *nd, struct vfsmount *nfsmnt);

677

678

int au_copy_file(struct file *dst, struct file *src, loff_t len,

679

- struct super_block *sb);

680

+ struct super_block *sb, struct vfsmount *dst_mnt);

681

int au_test_ro(struct super_block *sb, aufs_bindex_t bindex,

682

struct inode *inode);

683

int au_test_perm(struct inode *h_inode, int mask, int dlgt);

684

diff -urNad aufs-0+20071211~/fs/aufs/plink.c aufs-0+20071211/fs/aufs/plink.c

685

--- aufs-0+20071211~/fs/aufs/plink.c 2007-10-29 05:41:10.000000000 +0100

686

+++ aufs-0+20071211/fs/aufs/plink.c 2007-12-11 19:18:51.000000000 +0100

687

@@ -119,8 +119,8 @@

688

}

689

690

static int do_whplink(char *tgt, int len, struct dentry *h_parent,

691

- struct dentry *h_dentry, struct vfsmount *nfsmnt,

692

- struct super_block *sb)

693

+ struct dentry *h_dentry, struct vfsmount *h_mnt,

694

+ struct vfsmount *nfsmnt, struct super_block *sb)

695

{

696

int err;

697

struct dentry *h_tgt;

698

@@ -142,9 +142,9 @@

699

vfsub_args_init(&vargs, NULL, ndx.dlgt, 0);

700

h_dir = h_parent->d_inode;

701

if (unlikely(h_tgt->d_inode && h_tgt->d_inode != h_dentry->d_inode))

702

- err = vfsub_unlink(h_dir, h_tgt, &vargs);

703

+ err = vfsub_unlink(h_dir, h_tgt, h_mnt, &vargs);

704

if (!err && !h_tgt->d_inode) {

705

- err = vfsub_link(h_dentry, h_dir, h_tgt, ndx.dlgt);

706

+ err = vfsub_link(h_dentry, h_mnt, h_dir, h_tgt, h_mnt, ndx.dlgt);

707

//inode->i_nlink++;

708

}

709

dput(h_tgt);

710

@@ -160,6 +160,7 @@

711

int len;

712

struct dentry *h_parent;

713

struct dentry *h_dentry;

714

+ struct vfsmount *h_mnt;

715

struct vfsmount *nfsmnt;

716

struct super_block *sb;

717

};

718

@@ -168,7 +169,7 @@

719

{

720

struct do_whplink_args *a = args;

721

*a->errp = do_whplink(a->tgt, a->len, a->h_parent, a->h_dentry,

722

- a->nfsmnt, a->sb);

723

+ a->h_mnt, a->nfsmnt, a->sb);

724

}

725

726

static int whplink(struct dentry *h_dentry, struct inode *inode,

727

@@ -198,6 +199,7 @@

728

.len = len,

729

.h_parent = h_parent,

730

.h_dentry = h_dentry,

731

+ .h_mnt = br->br_mnt,

732

.nfsmnt = au_do_nfsmnt(br->br_mnt),

733

.sb = sb

734

};

735

@@ -206,7 +208,7 @@

736

err = wkq_err;

737

} else

738

err = do_whplink(tgtname, len, h_parent, h_dentry,

739

- au_do_nfsmnt(br->br_mnt), sb);

740

+ br->br_mnt, au_do_nfsmnt(br->br_mnt), sb);

741

vfsub_i_unlock(h_dir);

742

743

AuTraceErr(err);

744

diff -urNad aufs-0+20071211~/fs/aufs/vfsub.c aufs-0+20071211/fs/aufs/vfsub.c

745

--- aufs-0+20071211~/fs/aufs/vfsub.c 2007-12-10 02:20:14.000000000 +0100

746

+++ aufs-0+20071211/fs/aufs/vfsub.c 2007-12-11 19:18:51.000000000 +0100

747

@@ -156,6 +156,7 @@

748

int *errp;

749

struct inode *dir;

750

struct dentry *dentry;

751

+ struct vfsmount *mnt;

752

const char *symname;

753

int mode;

754

};

755

@@ -163,20 +164,22 @@

756

static void call_symlink(void *args)

757

{

758

struct symlink_args *a = args;

759

- *a->errp = do_vfsub_symlink(a->dir, a->dentry, a->symname, a->mode);

760

+ *a->errp = do_vfsub_symlink(a->dir, a->dentry, a->mnt, a->symname,

761

+ a->mode);

762

}

763

764

-int vfsub_symlink(struct inode *dir, struct dentry *dentry, const char *symname,

765

- int mode, int dlgt)

766

+int vfsub_symlink(struct inode *dir, struct dentry *dentry,

767

+ struct vfsmount *mnt, const char *symname, int mode, int dlgt)

768

{

769

if (!dlgt)

770

- return do_vfsub_symlink(dir, dentry, symname, mode);

771

+ return do_vfsub_symlink(dir, dentry, mnt, symname, mode);

772

else {

773

int err, wkq_err;

774

struct symlink_args args = {

775

.errp = &err,

776

.dir = dir,

777

.dentry = dentry,

778

+ .mnt = mnt,

779

.symname = symname,

780

.mode = mode

781

};

782

@@ -191,6 +194,7 @@

783

int *errp;

784

struct inode *dir;

785

struct dentry *dentry;

786

+ struct vfsmount *mnt;

787

int mode;

788

dev_t dev;

789

};

790

@@ -198,20 +202,21 @@

791

static void call_mknod(void *args)

792

{

793

struct mknod_args *a = args;

794

- *a->errp = do_vfsub_mknod(a->dir, a->dentry, a->mode, a->dev);

795

+ *a->errp = do_vfsub_mknod(a->dir, a->dentry, a->mnt, a->mode, a->dev);

796

}

797

798

-int vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev,

799

- int dlgt)

800

+int vfsub_mknod(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

801

+ int mode, dev_t dev, int dlgt)

802

{

803

if (!dlgt)

804

- return do_vfsub_mknod(dir, dentry, mode, dev);

805

+ return do_vfsub_mknod(dir, dentry, mnt, mode, dev);

806

else {

807

int err, wkq_err;

808

struct mknod_args args = {

809

.errp = &err,

810

.dir = dir,

811

.dentry = dentry,

812

+ .mnt = mnt,

813

.mode = mode,

814

.dev = dev

815

};

816

@@ -226,25 +231,28 @@

817

int *errp;

818

struct inode *dir;

819

struct dentry *dentry;

820

+ struct vfsmount *mnt;

821

int mode;

822

};

823

824

static void call_mkdir(void *args)

825

{

826

struct mkdir_args *a = args;

827

- *a->errp = do_vfsub_mkdir(a->dir, a->dentry, a->mode);

828

+ *a->errp = do_vfsub_mkdir(a->dir, a->dentry, a->mnt, a->mode);

829

}

830

831

-int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt)

832

+int vfsub_mkdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

833

+ int mode, int dlgt)

834

{

835

if (!dlgt)

836

- return do_vfsub_mkdir(dir, dentry, mode);

837

+ return do_vfsub_mkdir(dir, dentry, mnt, mode);

838

else {

839

int err, wkq_err;

840

struct mkdir_args args = {

841

.errp = &err,

842

.dir = dir,

843

.dentry = dentry,

844

+ .mnt = mnt,

845

.mode = mode

846

};

847

wkq_err = au_wkq_wait(call_mkdir, &args, /*dlgt*/1);

848

@@ -260,6 +268,7 @@

849

int *errp;

850

struct inode *dir;

851

struct dentry *src_dentry, *dentry;

852

+ struct vfsmount *src_mnt, *mnt;

853

};

854

855

static void call_link(void *args)

856

@@ -268,18 +277,21 @@

857

*a->errp = do_vfsub_link(a->src_dentry, a->dir, a->dentry);

858

}

859

860

-int vfsub_link(struct dentry *src_dentry, struct inode *dir,

861

- struct dentry *dentry, int dlgt)

862

+int vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,

863

+ struct inode *dir, struct dentry *dentry,

864

+ struct vfsmount *mnt, int dlgt)

865

{

866

if (!dlgt)

867

- return do_vfsub_link(src_dentry, dir, dentry);

868

+ return do_vfsub_link(src_dentry, src_mnt, dir, dentry, mnt);

869

else {

870

int err, wkq_err;

871

struct link_args args = {

872

.errp = &err,

873

.src_dentry = src_dentry,

874

+ .src_mnt = src_mnt,

875

.dir = dir,

876

- .dentry = dentry

877

+ .dentry = dentry,

878

+ .mnt = mnt

879

};

880

wkq_err = au_wkq_wait(call_link, &args, /*dlgt*/1);

881

if (unlikely(wkq_err))

882

@@ -292,6 +304,7 @@

883

int *errp;

884

struct inode *src_dir, *dir;

885

struct dentry *src_dentry, *dentry;

886

+ struct vfsmount *src_mnt, *mnt;

887

struct vfsub_args *vargs;

888

};

889

890

@@ -299,21 +312,23 @@

891

{

892

struct rename_args *a = args;

893

vfsub_ignore(a->vargs);

894

- *a->errp = do_vfsub_rename(a->src_dir, a->src_dentry, a->dir,

895

- a->dentry);

896

+ *a->errp = do_vfsub_rename(a->src_dir, a->src_dentry, a->src_mnt,

897

+ a->dir, a->dentry, a->mnt);

898

if (unlikely(*a->errp))

899

vfsub_unignore(a->vargs);

900

}

901

902

int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,

903

- struct inode *dir, struct dentry *dentry,

904

+ struct vfsmount *src_mnt,

905

+ struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

906

struct vfsub_args *vargs)

907

{

908

int err;

909

910

if (!vargs->dlgt) {

911

vfsub_ignore(vargs);

912

- err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);

913

+ err = do_vfsub_rename(src_dir, src_dentry, src_mnt, dir, dentry,

914

+ mnt);

915

if (unlikely(err))

916

vfsub_unignore(vargs);

917

} else {

918

@@ -322,8 +337,10 @@

919

.errp = &err,

920

.src_dir = src_dir,

921

.src_dentry = src_dentry,

922

+ .src_mnt = src_mnt,

923

.dir = dir,

924

.dentry = dentry,

925

+ .mnt = mnt,

926

.vargs = vargs

927

};

928

wkq_err = au_wkq_wait(call_rename, &args, /*dlgt*/1);

929

@@ -337,6 +354,7 @@

930

int *errp;

931

struct inode *dir;

932

struct dentry *dentry;

933

+ struct vfsmount *mnt;

934

struct vfsub_args *vargs;

935

};

936

937

@@ -344,19 +362,19 @@

938

{

939

struct rmdir_args *a = args;

940

vfsub_ignore(a->vargs);

941

- *a->errp = do_vfsub_rmdir(a->dir, a->dentry);

942

+ *a->errp = do_vfsub_rmdir(a->dir, a->dentry, a->mnt);

943

if (unlikely(*a->errp))

944

vfsub_unignore(a->vargs);

945

}

946

947

-int vfsub_rmdir(struct inode *dir, struct dentry *dentry,

948

+int vfsub_rmdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

949

struct vfsub_args *vargs)

950

{

951

int err;

952

953

if (!vargs->dlgt) {

954

vfsub_ignore(vargs);

955

- err = do_vfsub_rmdir(dir, dentry);

956

+ err = do_vfsub_rmdir(dir, dentry, mnt);

957

if (unlikely(err))

958

vfsub_unignore(vargs);

959

} else {

960

@@ -365,6 +383,7 @@

961

.errp = &err,

962

.dir = dir,

963

.dentry = dentry,

964

+ .mnt = mnt,

965

.vargs = vargs

966

};

967

wkq_err = au_wkq_wait(call_rmdir, &args, /*dlgt*/1);

968

@@ -762,6 +781,7 @@

969

int *errp;

970

struct inode *dir;

971

struct dentry *dentry;

972

+ struct vfsmount *mnt;

973

int mode;

974

int dlgt;

975

};

976

@@ -769,11 +789,11 @@

977

static void au_call_vfsub_mkdir(void *args)

978

{

979

struct au_vfsub_mkdir_args *a = args;

980

- *a->errp = vfsub_mkdir(a->dir, a->dentry, a->mode, a->dlgt);

981

+ *a->errp = vfsub_mkdir(a->dir, a->dentry, a->mnt, a->mode, a->dlgt);

982

}

983

984

-int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,

985

- int dlgt)

986

+int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry,

987

+ struct vfsmount *mnt, int mode, int dlgt)

988

{

989

int err, do_sio, wkq_err;

990

991

@@ -781,12 +801,13 @@

992

993

do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);

994

if (!do_sio)

995

- err = vfsub_mkdir(dir, dentry, mode, dlgt);

996

+ err = vfsub_mkdir(dir, dentry, mnt, mode, dlgt);

997

else {

998

struct au_vfsub_mkdir_args args = {

999

.errp = &err,

1000

.dir = dir,

1001

.dentry = dentry,

1002

+ .mnt = mnt,

1003

.mode = mode,

1004

.dlgt = dlgt

1005

};

1006

@@ -803,16 +824,18 @@

1007

int *errp;

1008

struct inode *dir;

1009

struct dentry *dentry;

1010

+ struct vfsmount *mnt;

1011

struct vfsub_args *vargs;

1012

};

1013

1014

static void au_call_vfsub_rmdir(void *args)

1015

{

1016

struct au_vfsub_rmdir_args *a = args;

1017

- *a->errp = vfsub_rmdir(a->dir, a->dentry, a->vargs);

1018

+ *a->errp = vfsub_rmdir(a->dir, a->dentry, a->mnt, a->vargs);

1019

}

1020

1021

-int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt)

1022

+int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry,

1023

+ struct vfsmount *mnt, int dlgt)

1024

{

1025

int err, do_sio, wkq_err;

1026

struct vfsub_args vargs;

1027

@@ -822,12 +845,13 @@

1028

vfsub_args_init(&vargs, /*ign*/NULL, dlgt, /*force_unlink*/0);

1029

do_sio = au_test_perm(dir, MAY_EXEC | MAY_WRITE, dlgt);

1030

if (!do_sio)

1031

- err = vfsub_rmdir(dir, dentry, &vargs);

1032

+ err = vfsub_rmdir(dir, dentry, mnt, &vargs);

1033

else {

1034

struct au_vfsub_rmdir_args args = {

1035

.errp = &err,

1036

.dir = dir,

1037

.dentry = dentry,

1038

+ .mnt = mnt,

1039

.vargs = &vargs

1040

};

1041

wkq_err = au_wkq_wait(au_call_vfsub_rmdir, &args, /*dlgt*/0);

1042

@@ -844,6 +868,7 @@

1043

struct notify_change_args {

1044

int *errp;

1045

struct dentry *h_dentry;

1046

+ struct vfsmount *h_mnt;

1047

struct iattr *ia;

1048

struct vfsub_args *vargs;

1049

};

1050

@@ -862,7 +887,7 @@

1051

if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) {

1052

vfsub_ignore(a->vargs);

1053

lockdep_off();

1054

- *a->errp = notify_change(a->h_dentry, a->ia);

1055

+ *a->errp = notify_change(a->h_dentry, a->h_mnt, a->ia);

1056

lockdep_on();

1057

if (!*a->errp)

1058

au_update_fuse_h_inode(NULL, a->h_dentry); /*ignore*/

1059

@@ -872,13 +897,14 @@

1060

AuTraceErr(*a->errp);

1061

}

1062

1063

-int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,

1064

- struct vfsub_args *vargs)

1065

+int vfsub_notify_change(struct dentry *dentry, struct vfsmount *mnt,

1066

+ struct iattr *ia, struct vfsub_args *vargs)

1067

{

1068

int err;

1069

struct notify_change_args args = {

1070

.errp = &err,

1071

.h_dentry = dentry,

1072

+ .h_mnt = mnt,

1073

.ia = ia,

1074

.vargs = vargs

1075

};

1076

@@ -906,6 +932,7 @@

1077

int *errp;

1078

struct inode *dir;

1079

struct dentry *dentry;

1080

+ struct vfsmount *mnt;

1081

struct vfsub_args *vargs;

1082

};

1083

1084

@@ -936,7 +963,7 @@

1085

err = -1;

1086

}

1087

#else

1088

- *a->errp = do_vfsub_unlink(a->dir, a->dentry);

1089

+ *a->errp = do_vfsub_unlink(a->dir, a->dentry, a->mnt);

1090

#endif

1091

1092

if (!stop_sillyrename)

1093

@@ -951,7 +978,7 @@

1094

* @dir: must be locked.

1095

* @dentry: target dentry.

1096

*/

1097

-int vfsub_unlink(struct inode *dir, struct dentry *dentry,

1098

+int vfsub_unlink(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1099

struct vfsub_args *vargs)

1100

{

1101

int err;

1102

@@ -959,6 +986,7 @@

1103

.errp = &err,

1104

.dir = dir,

1105

.dentry = dentry,

1106

+ .mnt = mnt,

1107

.vargs = vargs

1108

};

1109

1110

diff -urNad aufs-0+20071211~/fs/aufs/vfsub.h aufs-0+20071211/fs/aufs/vfsub.h

1111

--- aufs-0+20071211~/fs/aufs/vfsub.h 2007-11-12 02:43:10.000000000 +0100

1112

+++ aufs-0+20071211/fs/aufs/vfsub.h 2007-12-11 19:18:51.000000000 +0100

1113

@@ -337,7 +337,7 @@

1114

1115

static inline

1116

int do_vfsub_symlink(struct inode *dir, struct dentry *dentry,

1117

- const char *symname, int mode)

1118

+ struct vfsmount *mnt, const char *symname, int mode)

1119

{

1120

int err;

1121

1122

@@ -345,7 +345,7 @@

1123

dir->i_ino, AuDLNPair(dentry), symname, mode);

1124

IMustLock(dir);

1125

1126

- err = vfs_symlink(dir, dentry, symname, mode);

1127

+ err = vfs_symlink(dir, dentry, mnt, symname, mode);

1128

if (!err) {

1129

/* dir inode is locked */

1130

au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/

1131

@@ -355,15 +355,15 @@

1132

}

1133

1134

static inline

1135

-int do_vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode,

1136

- dev_t dev)

1137

+int do_vfsub_mknod(struct inode *dir, struct dentry *dentry,

1138

+ struct vfsmount *mnt, int mode, dev_t dev)

1139

{

1140

int err;

1141

1142

LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);

1143

IMustLock(dir);

1144

1145

- err = vfs_mknod(dir, dentry, mode, dev);

1146

+ err = vfs_mknod(dir, dentry, mnt, mode, dev);

1147

if (!err) {

1148

/* dir inode is locked */

1149

au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/

1150

@@ -373,8 +373,9 @@

1151

}

1152

1153

static inline

1154

-int do_vfsub_link(struct dentry *src_dentry, struct inode *dir,

1155

- struct dentry *dentry)

1156

+int do_vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,

1157

+ struct inode *dir, struct dentry *dentry,

1158

+ struct vfsmount *mnt)

1159

{

1160

int err;

1161

1162

@@ -383,7 +384,7 @@

1163

IMustLock(dir);

1164

1165

lockdep_off();

1166

- err = vfs_link(src_dentry, dir, dentry);

1167

+ err = vfs_link(src_dentry, src_mnt, dir, dentry, mnt);

1168

lockdep_on();

1169

if (!err) {

1170

LKTRTrace("src_i %p, dst_i %p\n",

1171

@@ -399,7 +400,9 @@

1172

1173

static inline

1174

int do_vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,

1175

- struct inode *dir, struct dentry *dentry)

1176

+ struct vfsmount *src_mnt,

1177

+ struct inode *dir, struct dentry *dentry,

1178

+ struct vfsmount *mnt)

1179

{

1180

int err;

1181

1182

@@ -410,7 +413,7 @@

1183

IMustLock(src_dir);

1184

1185

lockdep_off();

1186

- err = vfs_rename(src_dir, src_dentry, dir, dentry);

1187

+ err = vfs_rename(src_dir, src_dentry, src_mnt, dir, dentry, mnt);

1188

lockdep_on();

1189

if (!err) {

1190

/* dir inode is locked */

1191

@@ -422,14 +425,15 @@

1192

}

1193

1194

static inline

1195

-int do_vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode)

1196

+int do_vfsub_mkdir(struct inode *dir, struct dentry *dentry,

1197

+ struct vfsmount *mnt, int mode)

1198

{

1199

int err;

1200

1201

LKTRTrace("i%lu, %.*s, 0x%x\n", dir->i_ino, AuDLNPair(dentry), mode);

1202

IMustLock(dir);

1203

1204

- err = vfs_mkdir(dir, dentry, mode);

1205

+ err = vfs_mkdir(dir, dentry, mnt, mode);

1206

if (!err) {

1207

/* dir inode is locked */

1208

au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/

1209

@@ -438,7 +442,8 @@

1210

return err;

1211

}

1212

1213

-static inline int do_vfsub_rmdir(struct inode *dir, struct dentry *dentry)

1214

+static inline int do_vfsub_rmdir(struct inode *dir, struct dentry *dentry,

1215

+ struct vfsmount *mnt)

1216

{

1217

int err;

1218

1219

@@ -446,7 +451,7 @@

1220

IMustLock(dir);

1221

1222

lockdep_off();

1223

- err = vfs_rmdir(dir, dentry);

1224

+ err = vfs_rmdir(dir, dentry, mnt);

1225

lockdep_on();

1226

/* dir inode is locked */

1227

if (!err)

1228

@@ -454,7 +459,8 @@

1229

return err;

1230

}

1231

1232

-static inline int do_vfsub_unlink(struct inode *dir, struct dentry *dentry)

1233

+static inline int do_vfsub_unlink(struct inode *dir, struct dentry *dentry,

1234

+ struct vfsmount *mnt)

1235

{

1236

int err;

1237

1238

@@ -463,7 +469,7 @@

1239

1240

/* vfs_unlink() locks inode */

1241

lockdep_off();

1242

- err = vfs_unlink(dir, dentry);

1243

+ err = vfs_unlink(dir, dentry, mnt);

1244

lockdep_on();

1245

/* dir inode is locked */

1246

if (!err)

1247

@@ -689,54 +695,57 @@

1248

}

1249

1250

static inline

1251

-int vfsub_symlink(struct inode *dir, struct dentry *dentry, const char *symname,

1252

- int mode, int dlgt)

1253

+int vfsub_symlink(struct inode *dir, struct dentry *dentry,

1254

+ struct vfsmount *mnt, const char *symname, int mode, int dlgt)

1255

{

1256

- return do_vfsub_symlink(dir, dentry, symname, mode);

1257

+ return do_vfsub_symlink(dir, dentry, mnt, symname, mode);

1258

}

1259

1260

static inline

1261

-int vfsub_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev,

1262

- int dlgt)

1263

+int vfsub_mknod(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1264

+ int mode, dev_t dev, int dlgt)

1265

{

1266

- return do_vfsub_mknod(dir, dentry, mode, dev);

1267

+ return do_vfsub_mknod(dir, dentry, mnt, mode, dev);

1268

}

1269

1270

static inline

1271

-int vfsub_link(struct dentry *src_dentry, struct inode *dir,

1272

- struct dentry *dentry, int dlgt)

1273

+int vfsub_link(struct dentry *src_dentry, struct vfsmount *src_mnt,

1274

+ struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1275

+ int dlgt)

1276

{

1277

- return do_vfsub_link(src_dentry, dir, dentry);

1278

+ return do_vfsub_link(src_dentry, src_mnt, dir, dentry, mnt);

1279

}

1280

1281

static inline

1282

int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,

1283

- struct inode *dir, struct dentry *dentry,

1284

+ struct vfsmount *src_mnt,

1285

+ struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1286

struct vfsub_args *vargs)

1287

{

1288

int err;

1289

1290

vfsub_ignore(vargs);

1291

- err = do_vfsub_rename(src_dir, src_dentry, dir, dentry);

1292

+ err = do_vfsub_rename(src_dir, src_dentry, src_mnt, dir, dentry, mnt);

1293

if (unlikely(err))

1294

vfsub_unignore(vargs);

1295

return err;

1296

}

1297

1298

static inline

1299

-int vfsub_mkdir(struct inode *dir, struct dentry *dentry, int mode, int dlgt)

1300

+int vfsub_mkdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1301

+ int mode, int dlgt)

1302

{

1303

- return do_vfsub_mkdir(dir, dentry, mode);

1304

+ return do_vfsub_mkdir(dir, dentry, mnt, mode);

1305

}

1306

1307

static inline

1308

-int vfsub_rmdir(struct inode *dir, struct dentry *dentry,

1309

+int vfsub_rmdir(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1310

struct vfsub_args *vargs)

1311

{

1312

int err;

1313

1314

vfsub_ignore(vargs);

1315

- err = do_vfsub_rmdir(dir, dentry);

1316

+ err = do_vfsub_rmdir(dir, dentry, mnt);

1317

if (unlikely(err))

1318

vfsub_unignore(vargs);

1319

return err;

1320

@@ -819,15 +828,16 @@

1321

1322

/* ---------------------------------------------------------------------- */

1323

1324

-int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry, int mode,

1325

- int dlgt);

1326

-int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry, int dlgt);

1327

+int vfsub_sio_mkdir(struct inode *dir, struct dentry *dentry,

1328

+ struct vfsmount *mnt, int mode, int dlgt);

1329

+int vfsub_sio_rmdir(struct inode *dir, struct dentry *dentry,

1330

+ struct vfsmount *mnt, int dlgt);

1331

1332

/* ---------------------------------------------------------------------- */

1333

1334

-int vfsub_notify_change(struct dentry *dentry, struct iattr *ia,

1335

- struct vfsub_args *vargs);

1336

-int vfsub_unlink(struct inode *dir, struct dentry *dentry,

1337

+int vfsub_notify_change(struct dentry *dentry, struct vfsmount *mnt,

1338

+ struct iattr *ia, struct vfsub_args *vargs);

1339

+int vfsub_unlink(struct inode *dir, struct dentry *dentry, struct vfsmount *mnt,

1340

struct vfsub_args *vargs);

1341

int vfsub_statfs(void *arg, struct kstatfs *buf, int dlgt);

1342

1343

diff -urNad aufs-0+20071211~/fs/aufs/wbr_policy.c aufs-0+20071211/fs/aufs/wbr_policy.c

1344

--- aufs-0+20071211~/fs/aufs/wbr_policy.c 2007-11-26 02:34:50.000000000 +0100

1345

+++ aufs-0+20071211/fs/aufs/wbr_policy.c 2007-12-11 19:18:51.000000000 +0100

1346

@@ -21,7 +21,8 @@

1347

#include <linux/statfs.h>

1348

#include "aufs.h"

1349

1350

-static int au_cpdown_attr(struct dentry *h_dst, struct dentry *h_src, int dlgt)

1351

+static int au_cpdown_attr(struct dentry *h_dst, struct dentry *h_src,

1352

+ struct vfsmount *h_dst_mnt, int dlgt)

1353

{

1354

int err, sbits;

1355

struct iattr ia;

1356

@@ -41,14 +42,14 @@

1357

sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));

1358

1359

vfsub_args_init(&vargs, NULL, dlgt, /*force_unlink*/0);

1360

- err = vfsub_notify_change(h_dst, &ia, &vargs);

1361

+ err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);

1362

1363

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)

1364

/* is this nfs only? */

1365

if (!err && sbits && au_test_nfs(h_dst->d_sb)) {

1366

ia.ia_valid = ATTR_FORCE | ATTR_MODE;

1367

ia.ia_mode = h_isrc->i_mode;

1368

- err = vfsub_notify_change(h_dst, &ia, &vargs);

1369

+ err = vfsub_notify_change(h_dst, h_dst_mnt, &ia, &vargs);

1370

}

1371

#endif

1372

if (!err)

1373

@@ -71,6 +72,7 @@

1374

aufs_bindex_t bend, bopq;

1375

struct dentry *h_dentry, *opq_dentry, *wh_dentry;

1376

struct inode *h_dir, *h_inode, *inode;

1377

+ struct vfsmount *h_mnt;

1378

1379

LKTRTrace("%.*s, b%d\n", AuDLNPair(dentry), bdst);

1380

AuDebugOn(dbstart(dentry) <= bdst

1381

@@ -84,9 +86,10 @@

1382

err = au_lkup_neg(dentry, bdst);

1383

if (unlikely(err < 0))

1384

goto out;

1385

+ h_mnt = sbr_mnt(dentry->d_sb, bdst);

1386

h_dentry = au_h_dptr_i(dentry, bdst);

1387

dlgt = au_need_dlgt(dentry->d_sb);

1388

- err = vfsub_sio_mkdir(h_dir, h_dentry, 0755, dlgt);

1389

+ err = vfsub_sio_mkdir(h_dir, h_dentry, h_mnt, 0755, dlgt);

1390

if (unlikely(err))

1391

goto out_put;

1392

1393

@@ -112,7 +115,7 @@

1394

diropq = 1;

1395

}

1396

1397

- err = au_cpdown_attr(h_dentry, au_h_dptr(dentry), dlgt);

1398

+ err = au_cpdown_attr(h_dentry, au_h_dptr(dentry), h_mnt, dlgt);

1399

vfsub_i_unlock(h_inode);

1400

if (unlikely(err))

1401

goto out_opq;

1402

@@ -125,8 +128,8 @@

1403

goto out_opq;

1404

err = 0;

1405

if (wh_dentry->d_inode)

1406

- err = au_unlink_wh_dentry(h_dir, wh_dentry, dentry,

1407

- NULL, dlgt);

1408

+ err = au_unlink_wh_dentry(h_dir, wh_dentry, h_mnt,

1409

+ dentry, NULL, dlgt);

1410

dput(wh_dentry);

1411

if (unlikely(err))

1412

goto out_opq;

1413

@@ -153,7 +156,7 @@

1414

}

1415

out_dir:

1416

if (made_dir) {

1417

- rerr = vfsub_sio_rmdir(h_dir, h_dentry, dlgt);

1418

+ rerr = vfsub_sio_rmdir(h_dir, h_dentry, h_mnt, dlgt);

1419

if (unlikely(rerr)) {

1420

AuIOErr("failed removing %.*s b%d (%d)\n",

1421

AuDLNPair(dentry), bdst, rerr);

1422

diff -urNad aufs-0+20071211~/fs/aufs/whout.c aufs-0+20071211/fs/aufs/whout.c

1423

--- aufs-0+20071211~/fs/aufs/whout.c 2007-11-12 02:43:10.000000000 +0100

1424

+++ aufs-0+20071211/fs/aufs/whout.c 2007-12-11 19:18:51.000000000 +0100

1425

@@ -219,6 +219,7 @@

1426

struct dentry *h_dentry, *h_parent, *tmp_dentry;

1427

struct super_block *sb;

1428

struct aufs_hin_ignore ign;

1429

+ struct vfsmount *h_mnt;

1430

struct vfsub_args vargs;

1431

struct aufs_ndx ndx = {

1432

.nd = NULL,

1433

@@ -240,13 +241,15 @@

1434

err = PTR_ERR(tmp_dentry);

1435

if (!IS_ERR(tmp_dentry)) {

1436

/* under the same dir, no need to lock_rename() */

1437

+ h_mnt = sbr_mnt(sb, bindex);

1438

vfsub_args_init(&vargs, &ign, ndx.dlgt, 0);

1439

AuDebugOn(!S_ISDIR(dentry->d_inode->i_mode));

1440

if (unlikely(au_flag_test_udba_inotify(sb)

1441

&& !noself))

1442

vfsub_ign_hinode(&vargs, IN_MOVE_SELF,

1443

itohi(dentry->d_inode, bindex));

1444

- err = vfsub_rename(h_dir, h_dentry, h_dir, tmp_dentry, &vargs);

1445

+ err = vfsub_rename(h_dir, h_dentry, h_mnt, h_dir, tmp_dentry,

1446

+ h_mnt, &vargs);

1447

//if (LktrCond) err = -1; //unavailable

1448

AuTraceErr(err);

1449

dput(tmp_dentry);

1450

@@ -259,7 +262,7 @@

1451

/* ---------------------------------------------------------------------- */

1452

1453

static int do_unlink_wh(struct inode *h_dir, struct dentry *wh_dentry,

1454

- struct inode *dir, int dlgt)

1455

+ struct vfsmount *h_mnt, struct inode *dir, int dlgt)

1456

{

1457

struct vfsub_args vargs;

1458

1459

@@ -274,11 +277,12 @@

1460

vfsub_args_init(&vargs, NULL, dlgt,

1461

(h_dir->i_mode & S_ISVTX)

1462

&& wh_dentry->d_inode->i_uid != current->fsuid);

1463

- return vfsub_unlink(h_dir, wh_dentry, &vargs);

1464

+ return vfsub_unlink(h_dir, wh_dentry, h_mnt, &vargs);

1465

}

1466

1467

int au_unlink_wh_dentry(struct inode *h_dir, struct dentry *wh_dentry,

1468

- struct dentry *dentry, struct inode *dir, int dlgt)

1469

+ struct vfsmount *h_mnt, struct dentry *dentry,

1470

+ struct inode *dir, int dlgt)

1471

{

1472

int err;

1473

1474

@@ -288,7 +292,7 @@

1475

|| !wh_dentry->d_inode

1476

|| !S_ISREG(wh_dentry->d_inode->i_mode));

1477

1478

- err = do_unlink_wh(h_dir, wh_dentry, dir, dlgt);

1479

+ err = do_unlink_wh(h_dir, wh_dentry, h_mnt, dir, dlgt);

1480

//if (LktrCond) err = -1; // unavailable

1481

if (!err && dentry)

1482

set_dbwh(dentry, -1);

1483

@@ -298,7 +302,8 @@

1484

}

1485

1486

static int unlink_wh_name(struct dentry *h_parent, struct qstr *wh,

1487

- struct inode *dir, struct aufs_ndx *ndx)

1488

+ struct vfsmount *h_mnt, struct inode *dir,

1489

+ struct aufs_ndx *ndx)

1490

{

1491

int err;

1492

struct inode *h_dir;

1493

@@ -314,7 +319,8 @@

1494

err = 0;

1495

if (h_dentry->d_inode

1496

&& S_ISREG(h_dentry->d_inode->i_mode))

1497

- err = do_unlink_wh(h_dir, h_dentry, dir, ndx->dlgt);

1498

+ err = do_unlink_wh(h_dir, h_dentry, h_mnt, dir,

1499

+ ndx->dlgt);

1500

dput(h_dentry);

1501

} else

1502

err = PTR_ERR(h_dentry);

1503

@@ -325,7 +331,8 @@

1504

1505

/* ---------------------------------------------------------------------- */

1506

1507

-static void clean_wh(struct inode *h_dir, struct dentry *wh)

1508

+static void clean_wh(struct inode *h_dir, struct dentry *wh,

1509

+ struct vfsmount *h_mnt)

1510

{

1511

int err;

1512

struct vfsub_args vargs;

1513

@@ -334,14 +341,15 @@

1514

1515

if (wh->d_inode) {

1516

vfsub_args_init(&vargs, NULL, 0, 0);

1517

- err = vfsub_unlink(h_dir, wh, &vargs);

1518

+ err = vfsub_unlink(h_dir, wh, h_mnt, &vargs);

1519

if (unlikely(err))

1520

AuWarn("failed unlink %.*s (%d), ignored.\n",

1521

AuDLNPair(wh), err);

1522

}

1523

}

1524

1525

-static void clean_plink(struct inode *h_dir, struct dentry *plink)

1526

+static void clean_plink(struct inode *h_dir, struct dentry *plink,

1527

+ struct vfsmount *h_mnt)

1528

{

1529

int err;

1530

struct vfsub_args vargs;

1531

@@ -350,7 +358,7 @@

1532

1533

if (plink->d_inode) {

1534

vfsub_args_init(&vargs, NULL, 0, 0);

1535

- err = vfsub_rmdir(h_dir, plink, &vargs);

1536

+ err = vfsub_rmdir(h_dir, plink, h_mnt, &vargs);

1537

if (unlikely(err))

1538

AuWarn("failed rmdir %.*s (%d), ignored.\n",

1539

AuDLNPair(plink), err);

1540

@@ -364,7 +372,8 @@

1541

return -ENOSYS;

1542

}

1543

1544

-static int plink_dir(struct inode *h_dir, struct dentry *plink)

1545

+static int plink_dir(struct inode *h_dir, struct dentry *plink,

1546

+ struct vfsmount *h_mnt)

1547

{

1548

int err;

1549

1550

@@ -373,7 +382,7 @@

1551

int mode = S_IRWXU;

1552

if (unlikely(au_test_nfs(plink->d_sb)))

1553

mode |= S_IXUGO;

1554

- err = vfsub_mkdir(h_dir, plink, mode, /*dlgt*/0);

1555

+ err = vfsub_mkdir(h_dir, plink, h_mnt, mode, /*dlgt*/0);

1556

} else if (S_ISDIR(plink->d_inode->i_mode))

1557

err = 0;

1558

else

1559

@@ -439,23 +448,23 @@

1560

case AuBr_RO:

1561

case AuBr_RRWH:

1562

case AuBr_ROWH:

1563

- clean_wh(h_dir, wh);

1564

- clean_plink(h_dir, plink);

1565

+ clean_wh(h_dir, wh, br->br_mnt);

1566

+ clean_plink(h_dir, plink, br->br_mnt);

1567

break;

1568

1569

case AuBr_RWNoLinkWH:

1570

- clean_wh(h_dir, wh);

1571

+ clean_wh(h_dir, wh, br->br_mnt);

1572

if (do_plink) {

1573

err = test_linkable(h_dir);

1574

if (unlikely(err))

1575

goto out_nolink;

1576

1577

- err = plink_dir(h_dir, plink);

1578

+ err = plink_dir(h_dir, plink, br->br_mnt);

1579

if (unlikely(err))

1580

goto out_err;

1581

br->br_plink = dget(plink);

1582

} else

1583

- clean_plink(h_dir, plink);

1584

+ clean_plink(h_dir, plink, br->br_mnt);

1585

break;

1586

1587

case AuBr_RW:

1588

@@ -484,12 +493,12 @@

1589

goto out_err;

1590

1591

if (do_plink) {

1592

- err = plink_dir(h_dir, plink);

1593

+ err = plink_dir(h_dir, plink, br->br_mnt);

1594

if (unlikely(err))

1595

goto out_err;

1596

br->br_plink = dget(plink);

1597

} else

1598

- clean_plink(h_dir, plink);

1599

+ clean_plink(h_dir, plink, br->br_mnt);

1600

br->br_wh = dget(wh);

1601

break;

1602

1603

@@ -547,7 +556,7 @@

1604

vfsub_args_init(&vargs, NULL, /*dlgt*/0, 0);

1605

hdir_lock(h_dir, dir, bindex);

1606

br_wh_write_lock(a->br);

1607

- err = vfsub_unlink(h_dir, a->br->br_wh, &vargs);

1608

+ err = vfsub_unlink(h_dir, a->br->br_wh, a->br->br_mnt, &vargs);

1609

//if (LktrCond) err = -1;

1610

dput(a->br->br_wh);

1611

a->br->br_wh = NULL;

1612

@@ -621,7 +630,8 @@

1613

br = stobr(sb, bindex);

1614

br_wh_read_lock(br);

1615

if (br->br_wh) {

1616

- err = vfsub_link(br->br_wh, h_dir, wh, dlgt);

1617

+ err = vfsub_link(br->br_wh, br->br_mnt, h_dir, wh, br->br_mnt,

1618

+ dlgt);

1619

if (!err || err != -EMLINK)

1620

goto out;

1621

1622

@@ -685,8 +695,8 @@

1623

} else {

1624

AuDebugOn(/* !S_ISDIR(dentry->d_inode->i_mode)

1625

* || */!opq_dentry->d_inode);

1626

- err = do_unlink_wh(h_dir, opq_dentry, dentry->d_inode,

1627

- ndx.dlgt);

1628

+ err = do_unlink_wh(h_dir, opq_dentry, sbr_mnt(sb, bindex),

1629

+ dentry->d_inode, ndx.dlgt);

1630

//if (LktrCond) err = -1;

1631

if (!err)

1632

set_dbdiropq(dentry, -1);

1633

@@ -817,6 +827,7 @@

1634

struct aufs_wh *tpos;

1635

struct hlist_node *pos;

1636

struct aufs_destr *str;

1637

+ struct vfsmount *h_mnt;

1638

1639

LKTRTrace("%.*s\n", AuDLNPair(h_parent));

1640

h_dir = h_parent->d_inode;

1641

@@ -834,6 +845,7 @@

1642

1643

/* already checked by au_test_perm(). */

1644

err = 0;

1645

+ h_mnt = sbr_mnt(inode->i_sb, bindex);

1646

for (i = 0; !err && i < AuSize_NHASH; i++) {

1647

head = whlist->heads + i;

1648

hlist_for_each_entry(tpos, pos, head, wh_hash) {

1649

@@ -843,8 +855,8 @@

1650

if (str->len + AUFS_WH_PFX_LEN <= PATH_MAX) {

1651

memcpy(p, str->name, str->len);

1652

wh_name.len = AUFS_WH_PFX_LEN + str->len;

1653

- err = unlink_wh_name(h_parent, &wh_name, inode,

1654

- ndx);

1655

+ err = unlink_wh_name(h_parent, &wh_name, h_mnt,

1656

+ inode, ndx);

1657

//if (LktrCond) err = -1;

1658

if (!err)

1659

continue;

1660

@@ -946,7 +958,7 @@

1661

&& !noself))

1662

vfsub_ign_hinode(&vargs, IN_DELETE_SELF,

1663

itohi(inode, bindex));

1664

- err = vfsub_rmdir(h_dir, h_dentry, &vargs);

1665

+ err = vfsub_rmdir(h_dir, h_dentry, sbr_mnt(sb, bindex), &vargs);

1666

//d_drop(h_dentry);

1667

//if (LktrCond) err = -1;

1668

}

1669

diff -urNad aufs-0+20071211~/fs/aufs/whout.h aufs-0+20071211/fs/aufs/whout.h

1670

--- aufs-0+20071211~/fs/aufs/whout.h 2007-10-01 06:48:51.000000000 +0200

1671

+++ aufs-0+20071211/fs/aufs/whout.h 2007-12-11 19:18:51.000000000 +0100

1672

@@ -39,7 +39,8 @@

1673

int rename_whtmp(struct inode *dir, struct dentry *dentry, aufs_bindex_t bindex,

1674

int noself);

1675

int au_unlink_wh_dentry(struct inode *h_dir, struct dentry *wh_dentry,

1676

- struct dentry *dentry, struct inode *dir, int dlgt);

1677

+ struct vfsmount *h_mnt, struct dentry *dentry,

1678

+ struct inode *dir, int dlgt);

1679

1680

struct aufs_branch;

1681

int init_wh(struct dentry *h_parent, struct aufs_branch *br,

1682

diff -urNad aufs-0+20071211~/fs/aufs/xino.c aufs-0+20071211/fs/aufs/xino.c

1683

--- aufs-0+20071211~/fs/aufs/xino.c 2007-12-10 02:19:54.000000000 +0100

1684

+++ aufs-0+20071211/fs/aufs/xino.c 2007-12-11 19:18:52.000000000 +0100

1685

@@ -520,7 +520,7 @@

1686

h_dir = h_parent->d_inode;

1687

vfsub_args_init(&vargs, NULL, 0, 0);

1688

vfsub_i_lock_nested(h_dir, AuLsc_I_PARENT);

1689

- err = vfsub_unlink(h_dir, file->f_dentry, &vargs);

1690

+ err = vfsub_unlink(h_dir, file->f_dentry, file->f_vfsmnt, &vargs);

1691

vfsub_i_unlock(h_dir);

1692

dput(h_parent);

1693

if (unlikely(err)) {

1694

@@ -611,7 +611,7 @@

1695

goto out_dput;

1696

}

1697

vfsub_args_init(&vargs, NULL, 0, 0);

1698

- err = vfsub_unlink(dir, dentry, &vargs);

1699

+ err = vfsub_unlink(dir, dentry, file->f_vfsmnt, &vargs);

1700

//if (LktrCond) err = -1;

1701

if (unlikely(err)) {

1702

AuErr("%.*s unlink err %d\n", AuLNPair(name), err);

1703

@@ -620,7 +620,8 @@

1704

1705

if (unlikely(copy_src)) {

1706

inode = copy_src->f_dentry->d_inode;

1707

- err = au_copy_file(file, copy_src, i_size_read(inode), sb);

1708

+ err = au_copy_file(file, copy_src, i_size_read(inode), sb,

1709

+ file->f_vfsmnt);

1710

if (unlikely(err)) {

1711

AuErr("%.*s copy err %d\n", AuLNPair(name), err);

1712

goto out_fput;