dir.c 45.4 KB
Newer Older
1
2
/*
  FUSE: Filesystem in Userspace
Miklos Szeredi's avatar
Miklos Szeredi committed
3
  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
4
5
6
7
8
9
10
11
12
13
14

  This program can be distributed under the terms of the GNU GPL.
  See the file COPYING.
*/

#include "fuse_i.h"

#include <linux/pagemap.h>
#include <linux/file.h>
#include <linux/sched.h>
#include <linux/namei.h>
15
#include <linux/slab.h>
Seth Forshee's avatar
Seth Forshee committed
16
#include <linux/xattr.h>
Seth Forshee's avatar
Seth Forshee committed
17
#include <linux/posix_acl.h>
18

Al Viro's avatar
Al Viro committed
19
static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
20
21
22
23
24
25
{
	struct fuse_conn *fc = get_fuse_conn(dir);
	struct fuse_inode *fi = get_fuse_inode(dir);

	if (!fc->do_readdirplus)
		return false;
26
27
	if (!fc->readdirplus_auto)
		return true;
28
29
	if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
		return true;
Al Viro's avatar
Al Viro committed
30
	if (ctx->pos == 0)
31
32
33
34
35
36
37
38
39
40
41
		return true;
	return false;
}

static void fuse_advise_use_readdirplus(struct inode *dir)
{
	struct fuse_inode *fi = get_fuse_inode(dir);

	set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
}

Miklos Szeredi's avatar
Miklos Szeredi committed
42
43
44
45
46
union fuse_dentry {
	u64 time;
	struct rcu_head rcu;
};

Miklos Szeredi's avatar
Miklos Szeredi committed
47
48
static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
49
	((union fuse_dentry *) entry->d_fsdata)->time = time;
Miklos Szeredi's avatar
Miklos Szeredi committed
50
51
52
53
}

static inline u64 fuse_dentry_time(struct dentry *entry)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
54
	return ((union fuse_dentry *) entry->d_fsdata)->time;
Miklos Szeredi's avatar
Miklos Szeredi committed
55
56
}

57
58
59
/*
 * FUSE caches dentries and attributes with separate timeout.  The
 * time in jiffies until the dentry/attributes are valid is stored in
Miklos Szeredi's avatar
Miklos Szeredi committed
60
 * dentry->d_fsdata and fuse_inode->i_time respectively.
61
62
63
64
65
 */

/*
 * Calculate the time in jiffies until a dentry/attributes are valid
 */
Miklos Szeredi's avatar
Miklos Szeredi committed
66
static u64 time_to_jiffies(u64 sec, u32 nsec)
67
{
68
	if (sec || nsec) {
Miklos Szeredi's avatar
Miklos Szeredi committed
69
70
71
72
73
74
		struct timespec64 ts = {
			sec,
			max_t(u32, nsec, NSEC_PER_SEC - 1)
		};

		return get_jiffies_64() + timespec64_to_jiffies(&ts);
75
	} else
Miklos Szeredi's avatar
Miklos Szeredi committed
76
		return 0;
77
78
}

79
80
81
82
/*
 * Set dentry and possibly attribute timeouts from the lookup/mk*
 * replies
 */
83
84
static void fuse_change_entry_timeout(struct dentry *entry,
				      struct fuse_entry_out *o)
85
{
Miklos Szeredi's avatar
Miklos Szeredi committed
86
87
	fuse_dentry_settime(entry,
		time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
88
89
90
91
92
93
94
95
96
97
}

static u64 attr_timeout(struct fuse_attr_out *o)
{
	return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
}

static u64 entry_attr_timeout(struct fuse_entry_out *o)
{
	return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
98
99
}

100
101
102
103
/*
 * Mark the attributes as stale, so that at the next call to
 * ->getattr() they will be fetched from userspace
 */
104
105
void fuse_invalidate_attr(struct inode *inode)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
106
	get_fuse_inode(inode)->i_time = 0;
107
108
}

109
110
111
112
113
114
115
116
117
118
/**
 * Mark the attributes as stale due to an atime change.  Avoid the invalidate if
 * atime is not used.
 */
void fuse_invalidate_atime(struct inode *inode)
{
	if (!IS_RDONLY(inode))
		fuse_invalidate_attr(inode);
}

119
120
121
122
123
124
125
126
/*
 * Just mark the entry as stale, so that a next attempt to look it up
 * will result in a new lookup call to userspace
 *
 * This is called when a dentry is about to become negative and the
 * timeout is unknown (unlink, rmdir, rename and in some cases
 * lookup)
 */
Miklos Szeredi's avatar
Miklos Szeredi committed
127
void fuse_invalidate_entry_cache(struct dentry *entry)
128
{
Miklos Szeredi's avatar
Miklos Szeredi committed
129
	fuse_dentry_settime(entry, 0);
130
131
}

132
133
134
135
/*
 * Same as fuse_invalidate_entry_cache(), but also try to remove the
 * dentry from the hash
 */
136
137
138
139
static void fuse_invalidate_entry(struct dentry *entry)
{
	d_invalidate(entry);
	fuse_invalidate_entry_cache(entry);
140
141
}

142
static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_args *args,
Al Viro's avatar
Al Viro committed
143
			     u64 nodeid, const struct qstr *name,
144
145
			     struct fuse_entry_out *outarg)
{
146
	memset(outarg, 0, sizeof(struct fuse_entry_out));
147
148
149
150
151
152
	args->in.h.opcode = FUSE_LOOKUP;
	args->in.h.nodeid = nodeid;
	args->in.numargs = 1;
	args->in.args[0].size = name->len + 1;
	args->in.args[0].value = name->name;
	args->out.numargs = 1;
153
	args->out.args[0].size = sizeof(struct fuse_entry_out);
154
	args->out.args[0].value = outarg;
155
156
}

157
u64 fuse_get_attr_version(struct fuse_conn *fc)
158
159
160
161
162
163
164
165
166
167
168
169
170
171
{
	u64 curr_version;

	/*
	 * The spin lock isn't actually needed on 64bit archs, but we
	 * don't yet care too much about such optimizations.
	 */
	spin_lock(&fc->lock);
	curr_version = fc->attr_version;
	spin_unlock(&fc->lock);

	return curr_version;
}

172
173
174
175
176
177
178
179
180
/*
 * Check whether the dentry is still valid
 *
 * If the entry validity timeout has expired and the dentry is
 * positive, try to redo the lookup.  If the lookup results in a
 * different inode, then let the VFS invalidate the dentry and redo
 * the lookup once more.  If the lookup results in the same inode,
 * then refresh the attributes, timeouts and mark the dentry valid.
 */
181
static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
182
{
183
	struct inode *inode;
184
185
	struct dentry *parent;
	struct fuse_conn *fc;
186
	struct fuse_inode *fi;
187
	int ret;
188

189
	inode = d_inode_rcu(entry);
190
	if (inode && is_bad_inode(inode))
191
		goto invalid;
192
193
	else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
		 (flags & LOOKUP_REVAL)) {
194
		struct fuse_entry_out outarg;
195
		FUSE_ARGS(args);
196
		struct fuse_forget_link *forget;
197
		u64 attr_version;
198

199
		/* For negative dentries, always do a fresh lookup */
200
		if (!inode)
201
			goto invalid;
202

203
		ret = -ECHILD;
204
		if (flags & LOOKUP_RCU)
205
			goto out;
206

207
		fc = get_fuse_conn(inode);
208

209
		forget = fuse_alloc_forget();
210
211
		ret = -ENOMEM;
		if (!forget)
212
			goto out;
213

214
		attr_version = fuse_get_attr_version(fc);
215

216
		parent = dget_parent(entry);
217
		fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)),
218
				 &entry->d_name, &outarg);
219
		ret = fuse_simple_request(fc, &args);
220
		dput(parent);
221
		/* Zero nodeid is same as -ENOENT */
222
223
224
		if (!ret && !outarg.nodeid)
			ret = -ENOENT;
		if (!ret) {
225
			fi = get_fuse_inode(inode);
226
			if (outarg.nodeid != get_node_id(inode)) {
227
				fuse_queue_forget(fc, forget, outarg.nodeid, 1);
228
				goto invalid;
229
			}
230
			spin_lock(&fc->lock);
Miklos Szeredi's avatar
Miklos Szeredi committed
231
			fi->nlookup++;
232
			spin_unlock(&fc->lock);
233
		}
234
		kfree(forget);
235
236
237
		if (ret == -ENOMEM)
			goto out;
		if (ret || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
238
			goto invalid;
239

Seth Forshee's avatar
Seth Forshee committed
240
		forget_all_cached_acls(inode);
241
242
243
244
		fuse_change_attributes(inode, &outarg.attr,
				       entry_attr_timeout(&outarg),
				       attr_version);
		fuse_change_entry_timeout(entry, &outarg);
245
	} else if (inode) {
246
247
248
249
250
		fi = get_fuse_inode(inode);
		if (flags & LOOKUP_RCU) {
			if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
				return -ECHILD;
		} else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
251
			parent = dget_parent(entry);
252
			fuse_advise_use_readdirplus(d_inode(parent));
253
254
			dput(parent);
		}
255
	}
256
257
258
259
260
261
262
	ret = 1;
out:
	return ret;

invalid:
	ret = 0;
	goto out;
263
264
}

265
static int invalid_nodeid(u64 nodeid)
266
267
268
269
{
	return !nodeid || nodeid == FUSE_ROOT_ID;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
270
271
272
273
274
275
276
277
278
279
280
281
282
static int fuse_dentry_init(struct dentry *dentry)
{
	dentry->d_fsdata = kzalloc(sizeof(union fuse_dentry), GFP_KERNEL);

	return dentry->d_fsdata ? 0 : -ENOMEM;
}
static void fuse_dentry_release(struct dentry *dentry)
{
	union fuse_dentry *fd = dentry->d_fsdata;

	kfree_rcu(fd, rcu);
}

Al Viro's avatar
Al Viro committed
283
const struct dentry_operations fuse_dentry_operations = {
284
	.d_revalidate	= fuse_dentry_revalidate,
Miklos Szeredi's avatar
Miklos Szeredi committed
285
286
	.d_init		= fuse_dentry_init,
	.d_release	= fuse_dentry_release,
287
288
};

289
290
291
292
293
const struct dentry_operations fuse_root_dentry_operations = {
	.d_init		= fuse_dentry_init,
	.d_release	= fuse_dentry_release,
};

294
int fuse_valid_type(int m)
295
296
297
298
299
{
	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
		S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
}

Al Viro's avatar
Al Viro committed
300
int fuse_lookup_name(struct super_block *sb, u64 nodeid, const struct qstr *name,
301
		     struct fuse_entry_out *outarg, struct inode **inode)
302
{
303
	struct fuse_conn *fc = get_fuse_conn_super(sb);
304
	FUSE_ARGS(args);
305
	struct fuse_forget_link *forget;
306
	u64 attr_version;
307
	int err;
308

309
310
311
312
	*inode = NULL;
	err = -ENAMETOOLONG;
	if (name->len > FUSE_NAME_MAX)
		goto out;
313
314


315
316
	forget = fuse_alloc_forget();
	err = -ENOMEM;
317
	if (!forget)
318
		goto out;
319

320
	attr_version = fuse_get_attr_version(fc);
321

322
323
	fuse_lookup_init(fc, &args, nodeid, name, outarg);
	err = fuse_simple_request(fc, &args);
324
	/* Zero nodeid is same as -ENOENT, but with valid timeout */
325
326
327
328
329
330
331
332
333
334
335
336
337
338
	if (err || !outarg->nodeid)
		goto out_put_forget;

	err = -EIO;
	if (!outarg->nodeid)
		goto out_put_forget;
	if (!fuse_valid_type(outarg->attr.mode))
		goto out_put_forget;

	*inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
			   &outarg->attr, entry_attr_timeout(outarg),
			   attr_version);
	err = -ENOMEM;
	if (!*inode) {
339
		fuse_queue_forget(fc, forget, outarg->nodeid, 1);
340
		goto out;
341
	}
342
343
344
	err = 0;

 out_put_forget:
345
	kfree(forget);
346
347
348
349
350
 out:
	return err;
}

static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
Al Viro's avatar
Al Viro committed
351
				  unsigned int flags)
352
353
354
355
356
357
358
{
	int err;
	struct fuse_entry_out outarg;
	struct inode *inode;
	struct dentry *newent;
	bool outarg_valid = true;

359
	fuse_lock_inode(dir);
360
361
	err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
			       &outarg, &inode);
362
	fuse_unlock_inode(dir);
363
364
365
366
367
368
369
370
371
372
	if (err == -ENOENT) {
		outarg_valid = false;
		err = 0;
	}
	if (err)
		goto out_err;

	err = -EIO;
	if (inode && get_node_id(inode) == FUSE_ROOT_ID)
		goto out_iput;
373

374
	newent = d_splice_alias(inode, entry);
375
376
377
	err = PTR_ERR(newent);
	if (IS_ERR(newent))
		goto out_err;
378

379
	entry = newent ? newent : entry;
380
	if (outarg_valid)
381
		fuse_change_entry_timeout(entry, &outarg);
382
383
	else
		fuse_invalidate_entry_cache(entry);
384

385
	fuse_advise_use_readdirplus(dir);
386
	return newent;
387
388
389
390
391

 out_iput:
	iput(inode);
 out_err:
	return ERR_PTR(err);
392
393
}

394
395
396
397
398
399
/*
 * Atomic create+open operation
 *
 * If the filesystem doesn't support this, then fall back to separate
 * 'mknod' + 'open' requests.
 */
Al Viro's avatar
Al Viro committed
400
static int fuse_create_open(struct inode *dir, struct dentry *entry,
Al Viro's avatar
Al Viro committed
401
			    struct file *file, unsigned flags,
Al Viro's avatar
Al Viro committed
402
			    umode_t mode, int *opened)
403
404
405
406
{
	int err;
	struct inode *inode;
	struct fuse_conn *fc = get_fuse_conn(dir);
407
	FUSE_ARGS(args);
408
	struct fuse_forget_link *forget;
409
	struct fuse_create_in inarg;
410
411
412
413
	struct fuse_open_out outopen;
	struct fuse_entry_out outentry;
	struct fuse_file *ff;

414
415
416
	/* Userspace expects S_IFREG in create mode */
	BUG_ON((mode & S_IFMT) != S_IFREG);

417
	forget = fuse_alloc_forget();
418
	err = -ENOMEM;
419
	if (!forget)
420
		goto out_err;
421

422
	err = -ENOMEM;
Tejun Heo's avatar
Tejun Heo committed
423
	ff = fuse_file_alloc(fc);
424
	if (!ff)
425
		goto out_put_forget_req;
426

427
428
429
	if (!fc->dont_mask)
		mode &= ~current_umask();

430
431
	flags &= ~O_NOCTTY;
	memset(&inarg, 0, sizeof(inarg));
432
	memset(&outentry, 0, sizeof(outentry));
433
434
	inarg.flags = flags;
	inarg.mode = mode;
435
	inarg.umask = current_umask();
436
437
438
	args.in.h.opcode = FUSE_CREATE;
	args.in.h.nodeid = get_node_id(dir);
	args.in.numargs = 2;
439
	args.in.args[0].size = sizeof(inarg);
440
441
442
443
	args.in.args[0].value = &inarg;
	args.in.args[1].size = entry->d_name.len + 1;
	args.in.args[1].value = entry->d_name.name;
	args.out.numargs = 2;
444
	args.out.args[0].size = sizeof(outentry);
445
446
447
448
	args.out.args[0].value = &outentry;
	args.out.args[1].size = sizeof(outopen);
	args.out.args[1].value = &outopen;
	err = fuse_simple_request(fc, &args);
449
	if (err)
450
451
452
		goto out_free_ff;

	err = -EIO;
453
	if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
454
455
		goto out_free_ff;

456
457
458
	ff->fh = outopen.fh;
	ff->nodeid = outentry.nodeid;
	ff->open_flags = outopen.open_flags;
459
	inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
460
			  &outentry.attr, entry_attr_timeout(&outentry), 0);
461
462
	if (!inode) {
		flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
463
		fuse_sync_release(ff, flags);
464
		fuse_queue_forget(fc, forget, outentry.nodeid, 1);
465
466
		err = -ENOMEM;
		goto out_err;
467
	}
468
	kfree(forget);
469
	d_instantiate(entry, inode);
470
	fuse_change_entry_timeout(entry, &outentry);
471
	fuse_invalidate_attr(dir);
Al Viro's avatar
Al Viro committed
472
473
	err = finish_open(file, entry, generic_file_open, opened);
	if (err) {
474
		fuse_sync_release(ff, flags);
475
476
477
	} else {
		file->private_data = fuse_file_get(ff);
		fuse_finish_open(inode, file);
478
	}
Al Viro's avatar
Al Viro committed
479
	return err;
480

481
out_free_ff:
482
	fuse_file_free(ff);
483
out_put_forget_req:
484
	kfree(forget);
485
out_err:
Al Viro's avatar
Al Viro committed
486
	return err;
487
488
489
}

static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
Al Viro's avatar
Al Viro committed
490
static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
Al Viro's avatar
Al Viro committed
491
			    struct file *file, unsigned flags,
Al Viro's avatar
Al Viro committed
492
			    umode_t mode, int *opened)
493
494
495
496
497
{
	int err;
	struct fuse_conn *fc = get_fuse_conn(dir);
	struct dentry *res = NULL;

498
	if (d_in_lookup(entry)) {
Al Viro's avatar
Al Viro committed
499
		res = fuse_lookup(dir, entry, 0);
500
		if (IS_ERR(res))
Al Viro's avatar
Al Viro committed
501
			return PTR_ERR(res);
502
503
504
505
506

		if (res)
			entry = res;
	}

507
	if (!(flags & O_CREAT) || d_really_is_positive(entry))
508
509
510
		goto no_open;

	/* Only creates */
511
	*opened |= FILE_CREATED;
512
513
514
515

	if (fc->no_create)
		goto mknod;

Al Viro's avatar
Al Viro committed
516
	err = fuse_create_open(dir, entry, file, flags, mode, opened);
Al Viro's avatar
Al Viro committed
517
	if (err == -ENOSYS) {
518
519
520
521
522
		fc->no_create = 1;
		goto mknod;
	}
out_dput:
	dput(res);
Al Viro's avatar
Al Viro committed
523
	return err;
524
525
526

mknod:
	err = fuse_mknod(dir, entry, mode, 0);
Al Viro's avatar
Al Viro committed
527
	if (err)
528
529
		goto out_dput;
no_open:
Al Viro's avatar
Al Viro committed
530
	return finish_no_open(file, res);
531
532
}

533
534
535
/*
 * Code shared between mknod, mkdir, symlink and link
 */
536
static int create_new_entry(struct fuse_conn *fc, struct fuse_args *args,
537
			    struct inode *dir, struct dentry *entry,
Al Viro's avatar
Al Viro committed
538
			    umode_t mode)
539
540
541
542
{
	struct fuse_entry_out outarg;
	struct inode *inode;
	int err;
543
	struct fuse_forget_link *forget;
544

545
	forget = fuse_alloc_forget();
546
	if (!forget)
547
		return -ENOMEM;
548

549
	memset(&outarg, 0, sizeof(outarg));
550
551
	args->in.h.nodeid = get_node_id(dir);
	args->out.numargs = 1;
552
	args->out.args[0].size = sizeof(outarg);
553
554
	args->out.args[0].value = &outarg;
	err = fuse_simple_request(fc, args);
555
556
557
	if (err)
		goto out_put_forget_req;

558
559
	err = -EIO;
	if (invalid_nodeid(outarg.nodeid))
560
		goto out_put_forget_req;
561
562

	if ((outarg.attr.mode ^ mode) & S_IFMT)
563
		goto out_put_forget_req;
564

565
	inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
566
			  &outarg.attr, entry_attr_timeout(&outarg), 0);
567
	if (!inode) {
568
		fuse_queue_forget(fc, forget, outarg.nodeid, 1);
569
570
		return -ENOMEM;
	}
571
	kfree(forget);
572

573
574
575
	err = d_instantiate_no_diralias(entry, inode);
	if (err)
		return err;
576

577
	fuse_change_entry_timeout(entry, &outarg);
578
579
	fuse_invalidate_attr(dir);
	return 0;
580

581
 out_put_forget_req:
582
	kfree(forget);
583
	return err;
584
585
}

Al Viro's avatar
Al Viro committed
586
static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
587
588
589
590
		      dev_t rdev)
{
	struct fuse_mknod_in inarg;
	struct fuse_conn *fc = get_fuse_conn(dir);
591
	FUSE_ARGS(args);
592

593
594
595
	if (!fc->dont_mask)
		mode &= ~current_umask();

596
597
598
	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
	inarg.rdev = new_encode_dev(rdev);
599
	inarg.umask = current_umask();
600
601
	args.in.h.opcode = FUSE_MKNOD;
	args.in.numargs = 2;
602
	args.in.args[0].size = sizeof(inarg);
603
604
605
606
	args.in.args[0].value = &inarg;
	args.in.args[1].size = entry->d_name.len + 1;
	args.in.args[1].value = entry->d_name.name;
	return create_new_entry(fc, &args, dir, entry, mode);
607
608
}

Al Viro's avatar
Al Viro committed
609
static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
Al Viro's avatar
Al Viro committed
610
		       bool excl)
611
612
613
614
{
	return fuse_mknod(dir, entry, mode, 0);
}

615
static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
616
617
618
{
	struct fuse_mkdir_in inarg;
	struct fuse_conn *fc = get_fuse_conn(dir);
619
	FUSE_ARGS(args);
620

621
622
623
	if (!fc->dont_mask)
		mode &= ~current_umask();

624
625
	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
626
	inarg.umask = current_umask();
627
628
629
630
631
632
633
	args.in.h.opcode = FUSE_MKDIR;
	args.in.numargs = 2;
	args.in.args[0].size = sizeof(inarg);
	args.in.args[0].value = &inarg;
	args.in.args[1].size = entry->d_name.len + 1;
	args.in.args[1].value = entry->d_name.name;
	return create_new_entry(fc, &args, dir, entry, S_IFDIR);
634
635
636
637
638
639
640
}

static int fuse_symlink(struct inode *dir, struct dentry *entry,
			const char *link)
{
	struct fuse_conn *fc = get_fuse_conn(dir);
	unsigned len = strlen(link) + 1;
641
	FUSE_ARGS(args);
642

643
644
645
646
647
648
649
	args.in.h.opcode = FUSE_SYMLINK;
	args.in.numargs = 2;
	args.in.args[0].size = entry->d_name.len + 1;
	args.in.args[0].value = entry->d_name.name;
	args.in.args[1].size = len;
	args.in.args[1].value = link;
	return create_new_entry(fc, &args, dir, entry, S_IFLNK);
650
651
}

Seth Forshee's avatar
Seth Forshee committed
652
void fuse_update_ctime(struct inode *inode)
653
654
{
	if (!IS_NOCMTIME(inode)) {
655
		inode->i_ctime = current_time(inode);
656
657
658
659
		mark_inode_dirty_sync(inode);
	}
}

660
661
662
663
static int fuse_unlink(struct inode *dir, struct dentry *entry)
{
	int err;
	struct fuse_conn *fc = get_fuse_conn(dir);
664
665
666
667
668
669
670
671
	FUSE_ARGS(args);

	args.in.h.opcode = FUSE_UNLINK;
	args.in.h.nodeid = get_node_id(dir);
	args.in.numargs = 1;
	args.in.args[0].size = entry->d_name.len + 1;
	args.in.args[0].value = entry->d_name.name;
	err = fuse_simple_request(fc, &args);
672
	if (!err) {
673
		struct inode *inode = d_inode(entry);
Miklos Szeredi's avatar
Miklos Szeredi committed
674
		struct fuse_inode *fi = get_fuse_inode(inode);
675

Miklos Szeredi's avatar
Miklos Szeredi committed
676
677
		spin_lock(&fc->lock);
		fi->attr_version = ++fc->attr_version;
678
679
680
681
682
683
684
685
		/*
		 * If i_nlink == 0 then unlink doesn't make sense, yet this can
		 * happen if userspace filesystem is careless.  It would be
		 * difficult to enforce correct nlink usage so just ignore this
		 * condition here
		 */
		if (inode->i_nlink > 0)
			drop_nlink(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
686
		spin_unlock(&fc->lock);
687
688
		fuse_invalidate_attr(inode);
		fuse_invalidate_attr(dir);
689
		fuse_invalidate_entry_cache(entry);
690
		fuse_update_ctime(inode);
691
692
693
694
695
696
697
698
699
	} else if (err == -EINTR)
		fuse_invalidate_entry(entry);
	return err;
}

static int fuse_rmdir(struct inode *dir, struct dentry *entry)
{
	int err;
	struct fuse_conn *fc = get_fuse_conn(dir);
700
701
702
703
704
705
706
707
	FUSE_ARGS(args);

	args.in.h.opcode = FUSE_RMDIR;
	args.in.h.nodeid = get_node_id(dir);
	args.in.numargs = 1;
	args.in.args[0].size = entry->d_name.len + 1;
	args.in.args[0].value = entry->d_name.name;
	err = fuse_simple_request(fc, &args);
708
	if (!err) {
709
		clear_nlink(d_inode(entry));
710
		fuse_invalidate_attr(dir);
711
		fuse_invalidate_entry_cache(entry);
712
713
714
715
716
	} else if (err == -EINTR)
		fuse_invalidate_entry(entry);
	return err;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
717
718
719
static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
			      struct inode *newdir, struct dentry *newent,
			      unsigned int flags, int opcode, size_t argsize)
720
721
{
	int err;
Miklos Szeredi's avatar
Miklos Szeredi committed
722
	struct fuse_rename2_in inarg;
723
	struct fuse_conn *fc = get_fuse_conn(olddir);
724
	FUSE_ARGS(args);
725

Miklos Szeredi's avatar
Miklos Szeredi committed
726
	memset(&inarg, 0, argsize);
727
	inarg.newdir = get_node_id(newdir);
Miklos Szeredi's avatar
Miklos Szeredi committed
728
	inarg.flags = flags;
729
730
731
732
733
734
735
736
737
738
	args.in.h.opcode = opcode;
	args.in.h.nodeid = get_node_id(olddir);
	args.in.numargs = 3;
	args.in.args[0].size = argsize;
	args.in.args[0].value = &inarg;
	args.in.args[1].size = oldent->d_name.len + 1;
	args.in.args[1].value = oldent->d_name.name;
	args.in.args[2].size = newent->d_name.len + 1;
	args.in.args[2].value = newent->d_name.name;
	err = fuse_simple_request(fc, &args);
739
	if (!err) {
740
		/* ctime changes */
741
742
		fuse_invalidate_attr(d_inode(oldent));
		fuse_update_ctime(d_inode(oldent));
743

Miklos Szeredi's avatar
Miklos Szeredi committed
744
		if (flags & RENAME_EXCHANGE) {
745
746
			fuse_invalidate_attr(d_inode(newent));
			fuse_update_ctime(d_inode(newent));
Miklos Szeredi's avatar
Miklos Szeredi committed
747
748
		}

749
750
751
		fuse_invalidate_attr(olddir);
		if (olddir != newdir)
			fuse_invalidate_attr(newdir);
752
753

		/* newent will end up negative */
754
755
		if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) {
			fuse_invalidate_attr(d_inode(newent));
756
			fuse_invalidate_entry_cache(newent);
757
			fuse_update_ctime(d_inode(newent));
758
		}
759
760
761
762
763
764
765
	} else if (err == -EINTR) {
		/* If request was interrupted, DEITY only knows if the
		   rename actually took place.  If the invalidation
		   fails (e.g. some process has CWD under the renamed
		   directory), then there can be inconsistency between
		   the dcache and the real filesystem.  Tough luck. */
		fuse_invalidate_entry(oldent);
766
		if (d_really_is_positive(newent))
767
768
769
770
771
772
			fuse_invalidate_entry(newent);
	}

	return err;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
773
774
775
776
777
778
779
780
781
782
static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
			struct inode *newdir, struct dentry *newent,
			unsigned int flags)
{
	struct fuse_conn *fc = get_fuse_conn(olddir);
	int err;

	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
		return -EINVAL;

Miklos Szeredi's avatar
Miklos Szeredi committed
783
784
785
	if (flags) {
		if (fc->no_rename2 || fc->minor < 23)
			return -EINVAL;
Miklos Szeredi's avatar
Miklos Szeredi committed
786

Miklos Szeredi's avatar
Miklos Szeredi committed
787
788
789
790
791
792
793
794
795
796
797
		err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
					 FUSE_RENAME2,
					 sizeof(struct fuse_rename2_in));
		if (err == -ENOSYS) {
			fc->no_rename2 = 1;
			err = -EINVAL;
		}
	} else {
		err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
					 FUSE_RENAME,
					 sizeof(struct fuse_rename_in));
Miklos Szeredi's avatar
Miklos Szeredi committed
798
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
799

Miklos Szeredi's avatar
Miklos Szeredi committed
800
	return err;
Miklos Szeredi's avatar
Miklos Szeredi committed
801
}
Miklos Szeredi's avatar
Miklos Szeredi committed
802

803
804
805
806
807
static int fuse_link(struct dentry *entry, struct inode *newdir,
		     struct dentry *newent)
{
	int err;
	struct fuse_link_in inarg;
808
	struct inode *inode = d_inode(entry);
809
	struct fuse_conn *fc = get_fuse_conn(inode);
810
	FUSE_ARGS(args);
811
812
813

	memset(&inarg, 0, sizeof(inarg));
	inarg.oldnodeid = get_node_id(inode);
814
815
816
817
818
819
820
	args.in.h.opcode = FUSE_LINK;
	args.in.numargs = 2;
	args.in.args[0].size = sizeof(inarg);
	args.in.args[0].value = &inarg;
	args.in.args[1].size = newent->d_name.len + 1;
	args.in.args[1].value = newent->d_name.name;
	err = create_new_entry(fc, &args, newdir, newent, inode->i_mode);
821
822
823
824
825
826
	/* Contrary to "normal" filesystems it can happen that link
	   makes two "logical" inodes point to the same "physical"
	   inode.  We invalidate the attributes of the old one, so it
	   will reflect changes in the backing inode (link count,
	   etc.)
	*/
Miklos Szeredi's avatar
Miklos Szeredi committed
827
828
829
830
831
832
833
	if (!err) {
		struct fuse_inode *fi = get_fuse_inode(inode);

		spin_lock(&fc->lock);
		fi->attr_version = ++fc->attr_version;
		inc_nlink(inode);
		spin_unlock(&fc->lock);
834
		fuse_invalidate_attr(inode);
835
		fuse_update_ctime(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
836
837
838
	} else if (err == -EINTR) {
		fuse_invalidate_attr(inode);
	}
839
840
841
	return err;
}

842
843
844
static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
			  struct kstat *stat)
{
Miklos Szeredi's avatar
Miklos Szeredi committed
845
	unsigned int blkbits;
846
847
848
	struct fuse_conn *fc = get_fuse_conn(inode);

	/* see the comment in fuse_change_attributes() */
849
	if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
850
		attr->size = i_size_read(inode);
851
852
		attr->mtime = inode->i_mtime.tv_sec;
		attr->mtimensec = inode->i_mtime.tv_nsec;
853
854
		attr->ctime = inode->i_ctime.tv_sec;
		attr->ctimensec = inode->i_ctime.tv_nsec;
855
	}
Miklos Szeredi's avatar
Miklos Szeredi committed
856

857
858
859
860
	stat->dev = inode->i_sb->s_dev;
	stat->ino = attr->ino;
	stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
	stat->nlink = attr->nlink;
861
862
	stat->uid = make_kuid(&init_user_ns, attr->uid);
	stat->gid = make_kgid(&init_user_ns, attr->gid);
863
864
865
866
867
868
869
870
871
	stat->rdev = inode->i_rdev;
	stat->atime.tv_sec = attr->atime;
	stat->atime.tv_nsec = attr->atimensec;
	stat->mtime.tv_sec = attr->mtime;
	stat->mtime.tv_nsec = attr->mtimensec;
	stat->ctime.tv_sec = attr->ctime;
	stat->ctime.tv_nsec = attr->ctimensec;
	stat->size = attr->size;
	stat->blocks = attr->blocks;
Miklos Szeredi's avatar
Miklos Szeredi committed
872
873
874
875
876
877
878

	if (attr->blksize != 0)
		blkbits = ilog2(attr->blksize);
	else
		blkbits = inode->i_sb->s_blocksize_bits;

	stat->blksize = 1 << blkbits;
879
880
}

881
882
static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
			   struct file *file)
883
884
{
	int err;
885
886
	struct fuse_getattr_in inarg;
	struct fuse_attr_out outarg;
887
	struct fuse_conn *fc = get_fuse_conn(inode);
888
	FUSE_ARGS(args);
889
890
	u64 attr_version;

891
	attr_version = fuse_get_attr_version(fc);
892

893
	memset(&inarg, 0, sizeof(inarg));
894
	memset(&outarg, 0, sizeof(outarg));
895
896
897
898
899
900
901
	/* Directories have separate file-handle space */
	if (file && S_ISREG(inode->i_mode)) {
		struct fuse_file *ff = file->private_data;

		inarg.getattr_flags |= FUSE_GETATTR_FH;
		inarg.fh = ff->fh;
	}
902
903
904
905
906
907
	args.in.h.opcode = FUSE_GETATTR;
	args.in.h.nodeid = get_node_id(inode);
	args.in.numargs = 1;
	args.in.args[0].size = sizeof(inarg);
	args.in.args[0].value = &inarg;
	args.out.numargs = 1;
908
	args.out.args[0].size = sizeof(outarg);
909
910
	args.out.args[0].value = &outarg;
	err = fuse_simple_request(fc, &args);
911
	if (!err) {
912
		if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
913
914
915
			make_bad_inode(inode);
			err = -EIO;
		} else {
916
917
			fuse_change_attributes(inode, &outarg.attr,
					       attr_timeout(&outarg),
918
919
					       attr_version);
			if (stat)
920
				fuse_fillattr(inode, &outarg.attr, stat);
921
922
923
924
925
		}
	}
	return err;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
926
927
928
929
930
931
932
int fuse_update_attributes(struct inode *inode, struct kstat *stat,
			   struct file *file, bool *refreshed)
{
	struct fuse_inode *fi = get_fuse_inode(inode);
	int err;
	bool r;

Miklos Szeredi's avatar
Miklos Szeredi committed
933
	if (time_before64(fi->i_time, get_jiffies_64())) {
Miklos Szeredi's avatar
Miklos Szeredi committed
934
		r = true;
Seth Forshee's avatar
Seth Forshee committed
935
		forget_all_cached_acls(inode);
Miklos Szeredi's avatar
Miklos Szeredi committed
936
937
938
939
940
941
942
		err = fuse_do_getattr(inode, stat, file);
	} else {
		r = false;
		err = 0;
		if (stat) {
			generic_fillattr(inode, stat);
			stat->mode = fi->orig_i_mode;
943
			stat->ino = fi->orig_ino;
Miklos Szeredi's avatar
Miklos Szeredi committed
944
945
946
947
948
949
950
951
952
		}
	}

	if (refreshed != NULL)
		*refreshed = r;

	return err;
}

John Muir's avatar
John Muir committed
953
int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
954
			     u64 child_nodeid, struct qstr *name)
John Muir's avatar
John Muir committed
955
956
957
958
959
960
961
962
963
964
{
	int err = -ENOTDIR;
	struct inode *parent;
	struct dentry *dir;
	struct dentry *entry;

	parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
	if (!parent)
		return -ENOENT;

Al Viro's avatar
Al Viro committed
965
	inode_lock(parent);
John Muir's avatar
John Muir committed
966
967
968
969
970
971
972
973
	if (!S_ISDIR(parent->i_mode))
		goto unlock;

	err = -ENOENT;
	dir = d_find_alias(parent);
	if (!dir)
		goto unlock;

974
	name->hash = full_name_hash(dir, name->name, name->len);
John Muir's avatar
John Muir committed
975
976
977
978
979
980
981
	entry = d_lookup(dir, name);
	dput(dir);
	if (!entry)
		goto unlock;

	fuse_invalidate_attr(parent);
	fuse_invalidate_entry(entry);
982

983
	if (child_nodeid != 0 && d_really_is_positive(entry)) {
Al Viro's avatar
Al Viro committed
984
		inode_lock(d_inode(entry));
985
		if (get_node_id(d_inode(entry)) != child_nodeid) {
986
987
988
989
990
991
992
			err = -ENOENT;
			goto badentry;
		}
		if (d_mountpoint(entry)) {
			err = -EBUSY;
			goto badentry;
		}
993
		if (d_is_dir(entry)) {
994
995
996
997
998
			shrink_dcache_parent(entry);
			if (!simple_empty(entry)) {
				err = -ENOTEMPTY;
				goto badentry;
			}
999
			d_inode(entry)->i_flags |= S_DEAD;
1000
1001
		}
		dont_mount(entry);
1002
		clear_nlink(d_inode(entry));
1003
1004
		err = 0;
 badentry:
Al Viro's avatar
Al Viro committed
1005
		inode_unlock(d_inode(entry));