dir.c 39.8 KB
Newer Older
1 2
/*
  FUSE: Filesystem in Userspace
M
Miklos Szeredi 已提交
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>
16

M
Miklos Szeredi 已提交
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
#if BITS_PER_LONG >= 64
static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
{
	entry->d_time = time;
}

static inline u64 fuse_dentry_time(struct dentry *entry)
{
	return entry->d_time;
}
#else
/*
 * On 32 bit archs store the high 32 bits of time in d_fsdata
 */
static void fuse_dentry_settime(struct dentry *entry, u64 time)
{
	entry->d_time = time;
	entry->d_fsdata = (void *) (unsigned long) (time >> 32);
}

static u64 fuse_dentry_time(struct dentry *entry)
{
	return (u64) entry->d_time +
		((u64) (unsigned long) entry->d_fsdata << 32);
}
#endif

44 45 46 47 48 49 50 51 52
/*
 * FUSE caches dentries and attributes with separate timeout.  The
 * time in jiffies until the dentry/attributes are valid is stored in
 * dentry->d_time and fuse_inode->i_time respectively.
 */

/*
 * Calculate the time in jiffies until a dentry/attributes are valid
 */
M
Miklos Szeredi 已提交
53
static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
54
{
M
Miklos Szeredi 已提交
55 56
	if (sec || nsec) {
		struct timespec ts = {sec, nsec};
M
Miklos Szeredi 已提交
57
		return get_jiffies_64() + timespec_to_jiffies(&ts);
M
Miklos Szeredi 已提交
58
	} else
M
Miklos Szeredi 已提交
59
		return 0;
60 61
}

62 63 64 65
/*
 * Set dentry and possibly attribute timeouts from the lookup/mk*
 * replies
 */
66 67
static void fuse_change_entry_timeout(struct dentry *entry,
				      struct fuse_entry_out *o)
68
{
M
Miklos Szeredi 已提交
69 70
	fuse_dentry_settime(entry,
		time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
71 72 73 74 75 76 77 78 79 80
}

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);
81 82
}

83 84 85 86
/*
 * Mark the attributes as stale, so that at the next call to
 * ->getattr() they will be fetched from userspace
 */
87 88
void fuse_invalidate_attr(struct inode *inode)
{
M
Miklos Szeredi 已提交
89
	get_fuse_inode(inode)->i_time = 0;
90 91
}

92 93 94 95 96 97 98 99
/*
 * 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)
 */
M
Miklos Szeredi 已提交
100
void fuse_invalidate_entry_cache(struct dentry *entry)
101
{
M
Miklos Szeredi 已提交
102
	fuse_dentry_settime(entry, 0);
103 104
}

105 106 107 108
/*
 * Same as fuse_invalidate_entry_cache(), but also try to remove the
 * dentry from the hash
 */
109 110 111 112
static void fuse_invalidate_entry(struct dentry *entry)
{
	d_invalidate(entry);
	fuse_invalidate_entry_cache(entry);
113 114
}

115 116
static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
			     u64 nodeid, struct qstr *name,
117 118
			     struct fuse_entry_out *outarg)
{
119
	memset(outarg, 0, sizeof(struct fuse_entry_out));
120
	req->in.h.opcode = FUSE_LOOKUP;
121
	req->in.h.nodeid = nodeid;
122
	req->in.numargs = 1;
123 124
	req->in.args[0].size = name->len + 1;
	req->in.args[0].value = name->name;
125
	req->out.numargs = 1;
126 127 128 129
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(struct fuse_entry_out);
130 131 132
	req->out.args[0].value = outarg;
}

133
u64 fuse_get_attr_version(struct fuse_conn *fc)
134 135 136 137 138 139 140 141 142 143 144 145 146 147
{
	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;
}

148 149 150 151 152 153 154 155 156
/*
 * 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.
 */
157 158
static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
{
159
	struct inode *inode;
160

161
	inode = ACCESS_ONCE(entry->d_inode);
162
	if (inode && is_bad_inode(inode))
163
		return 0;
M
Miklos Szeredi 已提交
164
	else if (fuse_dentry_time(entry) < get_jiffies_64()) {
165 166
		int err;
		struct fuse_entry_out outarg;
167 168
		struct fuse_conn *fc;
		struct fuse_req *req;
169
		struct fuse_forget_link *forget;
170
		struct dentry *parent;
171
		u64 attr_version;
172

173
		/* For negative dentries, always do a fresh lookup */
174 175 176
		if (!inode)
			return 0;

177
		if (nd && (nd->flags & LOOKUP_RCU))
178 179
			return -ECHILD;

180
		fc = get_fuse_conn(inode);
181 182
		req = fuse_get_req(fc);
		if (IS_ERR(req))
183 184
			return 0;

185 186
		forget = fuse_alloc_forget();
		if (!forget) {
M
Miklos Szeredi 已提交
187 188 189 190
			fuse_put_request(fc, req);
			return 0;
		}

191
		attr_version = fuse_get_attr_version(fc);
192

193
		parent = dget_parent(entry);
194 195
		fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
				 &entry->d_name, &outarg);
196
		fuse_request_send(fc, req);
197
		dput(parent);
198
		err = req->out.h.error;
M
Miklos Szeredi 已提交
199
		fuse_put_request(fc, req);
200 201 202
		/* Zero nodeid is same as -ENOENT */
		if (!err && !outarg.nodeid)
			err = -ENOENT;
203
		if (!err) {
204
			struct fuse_inode *fi = get_fuse_inode(inode);
205
			if (outarg.nodeid != get_node_id(inode)) {
206
				fuse_queue_forget(fc, forget, outarg.nodeid, 1);
207 208
				return 0;
			}
209
			spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
210
			fi->nlookup++;
211
			spin_unlock(&fc->lock);
212
		}
213
		kfree(forget);
214
		if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
215 216
			return 0;

217 218 219 220
		fuse_change_attributes(inode, &outarg.attr,
				       entry_attr_timeout(&outarg),
				       attr_version);
		fuse_change_entry_timeout(entry, &outarg);
221 222 223 224
	}
	return 1;
}

225
static int invalid_nodeid(u64 nodeid)
226 227 228 229
{
	return !nodeid || nodeid == FUSE_ROOT_ID;
}

A
Al Viro 已提交
230
const struct dentry_operations fuse_dentry_operations = {
231 232 233
	.d_revalidate	= fuse_dentry_revalidate,
};

234
int fuse_valid_type(int m)
235 236 237 238 239
{
	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
		S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
}

240 241 242 243
/*
 * Add a directory inode to a dentry, ensuring that no other dentry
 * refers to this inode.  Called with fc->inst_mutex.
 */
244 245
static struct dentry *fuse_d_add_directory(struct dentry *entry,
					   struct inode *inode)
246 247
{
	struct dentry *alias = d_find_alias(inode);
248
	if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
249 250 251 252
		/* This tries to shrink the subtree below alias */
		fuse_invalidate_entry(alias);
		dput(alias);
		if (!list_empty(&inode->i_dentry))
253 254 255
			return ERR_PTR(-EBUSY);
	} else {
		dput(alias);
256
	}
257
	return d_splice_alias(inode, entry);
258 259
}

260 261
int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
		     struct fuse_entry_out *outarg, struct inode **inode)
262
{
263
	struct fuse_conn *fc = get_fuse_conn_super(sb);
264
	struct fuse_req *req;
265
	struct fuse_forget_link *forget;
266
	u64 attr_version;
267
	int err;
268

269 270 271 272
	*inode = NULL;
	err = -ENAMETOOLONG;
	if (name->len > FUSE_NAME_MAX)
		goto out;
273

274
	req = fuse_get_req(fc);
275
	err = PTR_ERR(req);
276
	if (IS_ERR(req))
277
		goto out;
278

279 280 281
	forget = fuse_alloc_forget();
	err = -ENOMEM;
	if (!forget) {
M
Miklos Szeredi 已提交
282
		fuse_put_request(fc, req);
283
		goto out;
M
Miklos Szeredi 已提交
284 285
	}

286
	attr_version = fuse_get_attr_version(fc);
287

288
	fuse_lookup_init(fc, req, nodeid, name, outarg);
289
	fuse_request_send(fc, req);
290
	err = req->out.h.error;
M
Miklos Szeredi 已提交
291
	fuse_put_request(fc, req);
292
	/* Zero nodeid is same as -ENOENT, but with valid timeout */
293 294 295 296 297 298 299 300 301 302 303 304 305 306
	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) {
307
		fuse_queue_forget(fc, forget, outarg->nodeid, 1);
308
		goto out;
309
	}
310 311 312
	err = 0;

 out_put_forget:
313
	kfree(forget);
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
 out:
	return err;
}

static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
				  struct nameidata *nd)
{
	int err;
	struct fuse_entry_out outarg;
	struct inode *inode;
	struct dentry *newent;
	struct fuse_conn *fc = get_fuse_conn(dir);
	bool outarg_valid = true;

	err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
			       &outarg, &inode);
	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;
340

341 342
	if (inode && S_ISDIR(inode->i_mode)) {
		mutex_lock(&fc->inst_mutex);
343
		newent = fuse_d_add_directory(entry, inode);
344
		mutex_unlock(&fc->inst_mutex);
345 346 347 348
		err = PTR_ERR(newent);
		if (IS_ERR(newent))
			goto out_iput;
	} else {
349
		newent = d_splice_alias(inode, entry);
350
	}
351

352
	entry = newent ? newent : entry;
353
	if (outarg_valid)
354
		fuse_change_entry_timeout(entry, &outarg);
355 356
	else
		fuse_invalidate_entry_cache(entry);
357

358
	return newent;
359 360 361 362 363

 out_iput:
	iput(inode);
 out_err:
	return ERR_PTR(err);
364 365
}

366 367 368 369 370 371
/*
 * Atomic create+open operation
 *
 * If the filesystem doesn't support this, then fall back to separate
 * 'mknod' + 'open' requests.
 */
M
Miklos Szeredi 已提交
372 373 374 375 376 377 378
static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
			    struct nameidata *nd)
{
	int err;
	struct inode *inode;
	struct fuse_conn *fc = get_fuse_conn(dir);
	struct fuse_req *req;
379
	struct fuse_forget_link *forget;
380
	struct fuse_create_in inarg;
M
Miklos Szeredi 已提交
381 382 383 384
	struct fuse_open_out outopen;
	struct fuse_entry_out outentry;
	struct fuse_file *ff;
	struct file *file;
385
	int flags = nd->intent.open.flags;
M
Miklos Szeredi 已提交
386 387

	if (fc->no_create)
388
		return -ENOSYS;
M
Miklos Szeredi 已提交
389

390 391 392
	if (flags & O_DIRECT)
		return -EINVAL;

393 394 395
	forget = fuse_alloc_forget();
	if (!forget)
		return -ENOMEM;
396

397
	req = fuse_get_req(fc);
398
	err = PTR_ERR(req);
399
	if (IS_ERR(req))
400
		goto out_put_forget_req;
M
Miklos Szeredi 已提交
401

402
	err = -ENOMEM;
T
Tejun Heo 已提交
403
	ff = fuse_file_alloc(fc);
M
Miklos Szeredi 已提交
404 405 406
	if (!ff)
		goto out_put_request;

407 408 409
	if (!fc->dont_mask)
		mode &= ~current_umask();

M
Miklos Szeredi 已提交
410 411
	flags &= ~O_NOCTTY;
	memset(&inarg, 0, sizeof(inarg));
412
	memset(&outentry, 0, sizeof(outentry));
M
Miklos Szeredi 已提交
413 414
	inarg.flags = flags;
	inarg.mode = mode;
415
	inarg.umask = current_umask();
M
Miklos Szeredi 已提交
416 417 418
	req->in.h.opcode = FUSE_CREATE;
	req->in.h.nodeid = get_node_id(dir);
	req->in.numargs = 2;
419 420
	req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
						sizeof(inarg);
M
Miklos Szeredi 已提交
421 422 423 424
	req->in.args[0].value = &inarg;
	req->in.args[1].size = entry->d_name.len + 1;
	req->in.args[1].value = entry->d_name.name;
	req->out.numargs = 2;
425 426 427 428
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outentry);
M
Miklos Szeredi 已提交
429 430 431
	req->out.args[0].value = &outentry;
	req->out.args[1].size = sizeof(outopen);
	req->out.args[1].value = &outopen;
432
	fuse_request_send(fc, req);
M
Miklos Szeredi 已提交
433 434 435 436 437 438 439 440
	err = req->out.h.error;
	if (err) {
		if (err == -ENOSYS)
			fc->no_create = 1;
		goto out_free_ff;
	}

	err = -EIO;
441
	if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
M
Miklos Szeredi 已提交
442 443
		goto out_free_ff;

444
	fuse_put_request(fc, req);
445 446 447
	ff->fh = outopen.fh;
	ff->nodeid = outentry.nodeid;
	ff->open_flags = outopen.open_flags;
M
Miklos Szeredi 已提交
448
	inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
449
			  &outentry.attr, entry_attr_timeout(&outentry), 0);
M
Miklos Szeredi 已提交
450 451
	if (!inode) {
		flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
452
		fuse_sync_release(ff, flags);
453
		fuse_queue_forget(fc, forget, outentry.nodeid, 1);
454
		return -ENOMEM;
M
Miklos Szeredi 已提交
455
	}
456
	kfree(forget);
M
Miklos Szeredi 已提交
457
	d_instantiate(entry, inode);
458
	fuse_change_entry_timeout(entry, &outentry);
459
	fuse_invalidate_attr(dir);
M
Miklos Szeredi 已提交
460 461
	file = lookup_instantiate_filp(nd, entry, generic_file_open);
	if (IS_ERR(file)) {
462
		fuse_sync_release(ff, flags);
M
Miklos Szeredi 已提交
463 464
		return PTR_ERR(file);
	}
465 466
	file->private_data = fuse_file_get(ff);
	fuse_finish_open(inode, file);
M
Miklos Szeredi 已提交
467 468 469 470 471 472
	return 0;

 out_free_ff:
	fuse_file_free(ff);
 out_put_request:
	fuse_put_request(fc, req);
473
 out_put_forget_req:
474
	kfree(forget);
M
Miklos Szeredi 已提交
475 476 477
	return err;
}

478 479 480
/*
 * Code shared between mknod, mkdir, symlink and link
 */
481 482 483 484 485 486 487
static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
			    struct inode *dir, struct dentry *entry,
			    int mode)
{
	struct fuse_entry_out outarg;
	struct inode *inode;
	int err;
488
	struct fuse_forget_link *forget;
M
Miklos Szeredi 已提交
489

490 491
	forget = fuse_alloc_forget();
	if (!forget) {
M
Miklos Szeredi 已提交
492
		fuse_put_request(fc, req);
493
		return -ENOMEM;
M
Miklos Szeredi 已提交
494
	}
495

496
	memset(&outarg, 0, sizeof(outarg));
497 498
	req->in.h.nodeid = get_node_id(dir);
	req->out.numargs = 1;
499 500 501 502
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outarg);
503
	req->out.args[0].value = &outarg;
504
	fuse_request_send(fc, req);
505
	err = req->out.h.error;
M
Miklos Szeredi 已提交
506 507 508 509
	fuse_put_request(fc, req);
	if (err)
		goto out_put_forget_req;

510 511
	err = -EIO;
	if (invalid_nodeid(outarg.nodeid))
M
Miklos Szeredi 已提交
512
		goto out_put_forget_req;
513 514

	if ((outarg.attr.mode ^ mode) & S_IFMT)
M
Miklos Szeredi 已提交
515
		goto out_put_forget_req;
516

517
	inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
518
			  &outarg.attr, entry_attr_timeout(&outarg), 0);
519
	if (!inode) {
520
		fuse_queue_forget(fc, forget, outarg.nodeid, 1);
521 522
		return -ENOMEM;
	}
523
	kfree(forget);
524

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	if (S_ISDIR(inode->i_mode)) {
		struct dentry *alias;
		mutex_lock(&fc->inst_mutex);
		alias = d_find_alias(inode);
		if (alias) {
			/* New directory must have moved since mkdir */
			mutex_unlock(&fc->inst_mutex);
			dput(alias);
			iput(inode);
			return -EBUSY;
		}
		d_instantiate(entry, inode);
		mutex_unlock(&fc->inst_mutex);
	} else
		d_instantiate(entry, inode);
540

541
	fuse_change_entry_timeout(entry, &outarg);
542 543
	fuse_invalidate_attr(dir);
	return 0;
544

M
Miklos Szeredi 已提交
545
 out_put_forget_req:
546
	kfree(forget);
547
	return err;
548 549 550 551 552 553 554
}

static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
		      dev_t rdev)
{
	struct fuse_mknod_in inarg;
	struct fuse_conn *fc = get_fuse_conn(dir);
555 556 557
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
558

559 560 561
	if (!fc->dont_mask)
		mode &= ~current_umask();

562 563 564
	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
	inarg.rdev = new_encode_dev(rdev);
565
	inarg.umask = current_umask();
566 567
	req->in.h.opcode = FUSE_MKNOD;
	req->in.numargs = 2;
568 569
	req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
						sizeof(inarg);
570 571 572 573 574 575 576 577 578
	req->in.args[0].value = &inarg;
	req->in.args[1].size = entry->d_name.len + 1;
	req->in.args[1].value = entry->d_name.name;
	return create_new_entry(fc, req, dir, entry, mode);
}

static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
		       struct nameidata *nd)
{
579
	if (nd) {
M
Miklos Szeredi 已提交
580 581 582 583 584
		int err = fuse_create_open(dir, entry, mode, nd);
		if (err != -ENOSYS)
			return err;
		/* Fall back on mknod */
	}
585 586 587 588 589 590 591
	return fuse_mknod(dir, entry, mode, 0);
}

static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
{
	struct fuse_mkdir_in inarg;
	struct fuse_conn *fc = get_fuse_conn(dir);
592 593 594
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
595

596 597 598
	if (!fc->dont_mask)
		mode &= ~current_umask();

599 600
	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
601
	inarg.umask = current_umask();
602 603 604 605 606 607 608 609 610 611 612 613 614 615
	req->in.h.opcode = FUSE_MKDIR;
	req->in.numargs = 2;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = entry->d_name.len + 1;
	req->in.args[1].value = entry->d_name.name;
	return create_new_entry(fc, req, dir, entry, S_IFDIR);
}

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;
616 617 618
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
619 620 621 622 623 624 625 626 627 628 629 630 631 632

	req->in.h.opcode = FUSE_SYMLINK;
	req->in.numargs = 2;
	req->in.args[0].size = entry->d_name.len + 1;
	req->in.args[0].value = entry->d_name.name;
	req->in.args[1].size = len;
	req->in.args[1].value = link;
	return create_new_entry(fc, req, dir, entry, S_IFLNK);
}

static int fuse_unlink(struct inode *dir, struct dentry *entry)
{
	int err;
	struct fuse_conn *fc = get_fuse_conn(dir);
633 634 635
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
636 637 638 639 640 641

	req->in.h.opcode = FUSE_UNLINK;
	req->in.h.nodeid = get_node_id(dir);
	req->in.numargs = 1;
	req->in.args[0].size = entry->d_name.len + 1;
	req->in.args[0].value = entry->d_name.name;
642
	fuse_request_send(fc, req);
643 644 645 646 647
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
		struct inode *inode = entry->d_inode;

M
Miklos Szeredi 已提交
648 649 650 651 652
		/*
		 * Set nlink to zero so the inode can be cleared, if the inode
		 * does have more links this will be discovered at the next
		 * lookup/getattr.
		 */
653
		clear_nlink(inode);
654 655
		fuse_invalidate_attr(inode);
		fuse_invalidate_attr(dir);
656
		fuse_invalidate_entry_cache(entry);
657 658 659 660 661 662 663 664 665
	} 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);
666 667 668
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
669 670 671 672 673 674

	req->in.h.opcode = FUSE_RMDIR;
	req->in.h.nodeid = get_node_id(dir);
	req->in.numargs = 1;
	req->in.args[0].size = entry->d_name.len + 1;
	req->in.args[0].value = entry->d_name.name;
675
	fuse_request_send(fc, req);
676 677 678
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
679
		clear_nlink(entry->d_inode);
680
		fuse_invalidate_attr(dir);
681
		fuse_invalidate_entry_cache(entry);
682 683 684 685 686 687 688 689 690 691 692
	} else if (err == -EINTR)
		fuse_invalidate_entry(entry);
	return err;
}

static int fuse_rename(struct inode *olddir, struct dentry *oldent,
		       struct inode *newdir, struct dentry *newent)
{
	int err;
	struct fuse_rename_in inarg;
	struct fuse_conn *fc = get_fuse_conn(olddir);
693
	struct fuse_req *req = fuse_get_req(fc);
694

695 696
	if (IS_ERR(req))
		return PTR_ERR(req);
697 698 699 700 701 702 703 704 705 706 707 708

	memset(&inarg, 0, sizeof(inarg));
	inarg.newdir = get_node_id(newdir);
	req->in.h.opcode = FUSE_RENAME;
	req->in.h.nodeid = get_node_id(olddir);
	req->in.numargs = 3;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = oldent->d_name.len + 1;
	req->in.args[1].value = oldent->d_name.name;
	req->in.args[2].size = newent->d_name.len + 1;
	req->in.args[2].value = newent->d_name.name;
709
	fuse_request_send(fc, req);
710 711 712
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
713 714 715
		/* ctime changes */
		fuse_invalidate_attr(oldent->d_inode);

716 717 718
		fuse_invalidate_attr(olddir);
		if (olddir != newdir)
			fuse_invalidate_attr(newdir);
719 720

		/* newent will end up negative */
M
Miklos Szeredi 已提交
721 722
		if (newent->d_inode) {
			fuse_invalidate_attr(newent->d_inode);
723
			fuse_invalidate_entry_cache(newent);
M
Miklos Szeredi 已提交
724
		}
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
	} 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);
		if (newent->d_inode)
			fuse_invalidate_entry(newent);
	}

	return err;
}

static int fuse_link(struct dentry *entry, struct inode *newdir,
		     struct dentry *newent)
{
	int err;
	struct fuse_link_in inarg;
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
746 747 748
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769

	memset(&inarg, 0, sizeof(inarg));
	inarg.oldnodeid = get_node_id(inode);
	req->in.h.opcode = FUSE_LINK;
	req->in.numargs = 2;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = newent->d_name.len + 1;
	req->in.args[1].value = newent->d_name.name;
	err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
	/* 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.)
	*/
	if (!err || err == -EINTR)
		fuse_invalidate_attr(inode);
	return err;
}

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
			  struct kstat *stat)
{
	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;
	stat->uid = attr->uid;
	stat->gid = attr->gid;
	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;
	stat->blksize = (1 << inode->i_blkbits);
}

791 792
static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
			   struct file *file)
793 794
{
	int err;
795 796
	struct fuse_getattr_in inarg;
	struct fuse_attr_out outarg;
797
	struct fuse_conn *fc = get_fuse_conn(inode);
798 799 800 801
	struct fuse_req *req;
	u64 attr_version;

	req = fuse_get_req(fc);
802 803
	if (IS_ERR(req))
		return PTR_ERR(req);
804

805
	attr_version = fuse_get_attr_version(fc);
806

807
	memset(&inarg, 0, sizeof(inarg));
808
	memset(&outarg, 0, sizeof(outarg));
809 810 811 812 813 814 815
	/* 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;
	}
816 817
	req->in.h.opcode = FUSE_GETATTR;
	req->in.h.nodeid = get_node_id(inode);
818 819 820
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
821
	req->out.numargs = 1;
822 823 824 825
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outarg);
826
	req->out.args[0].value = &outarg;
827
	fuse_request_send(fc, req);
828 829 830
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
831
		if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
832 833 834
			make_bad_inode(inode);
			err = -EIO;
		} else {
835 836
			fuse_change_attributes(inode, &outarg.attr,
					       attr_timeout(&outarg),
837 838
					       attr_version);
			if (stat)
839
				fuse_fillattr(inode, &outarg.attr, stat);
840 841 842 843 844
		}
	}
	return err;
}

M
Miklos Szeredi 已提交
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
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;

	if (fi->i_time < get_jiffies_64()) {
		r = true;
		err = fuse_do_getattr(inode, stat, file);
	} else {
		r = false;
		err = 0;
		if (stat) {
			generic_fillattr(inode, stat);
			stat->mode = fi->orig_i_mode;
		}
	}

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

	return err;
}

J
John Muir 已提交
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
			     struct qstr *name)
{
	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;

	mutex_lock(&parent->i_mutex);
	if (!S_ISDIR(parent->i_mode))
		goto unlock;

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

	entry = d_lookup(dir, name);
	dput(dir);
	if (!entry)
		goto unlock;

	fuse_invalidate_attr(parent);
	fuse_invalidate_entry(entry);
	dput(entry);
	err = 0;

 unlock:
	mutex_unlock(&parent->i_mutex);
	iput(parent);
	return err;
}

907 908 909 910 911 912 913 914 915 916 917 918 919
/*
 * Calling into a user-controlled filesystem gives the filesystem
 * daemon ptrace-like capabilities over the requester process.  This
 * means, that the filesystem daemon is able to record the exact
 * filesystem operations performed, and can also control the behavior
 * of the requester process in otherwise impossible ways.  For example
 * it can delay the operation for arbitrary length of time allowing
 * DoS against the requester.
 *
 * For this reason only those processes can call into the filesystem,
 * for which the owner of the mount has ptrace privilege.  This
 * excludes processes started by other users, suid or sgid processes.
 */
M
Miklos Szeredi 已提交
920
int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
921
{
922 923
	const struct cred *cred;
	int ret;
924

925
	if (fc->flags & FUSE_ALLOW_OTHER)
926 927
		return 1;

928 929 930 931 932 933 934 935 936 937 938 939 940
	rcu_read_lock();
	ret = 0;
	cred = __task_cred(task);
	if (cred->euid == fc->user_id &&
	    cred->suid == fc->user_id &&
	    cred->uid  == fc->user_id &&
	    cred->egid == fc->group_id &&
	    cred->sgid == fc->group_id &&
	    cred->gid  == fc->group_id)
		ret = 1;
	rcu_read_unlock();

	return ret;
941 942
}

M
Miklos Szeredi 已提交
943 944 945 946 947 948 949 950 951 952
static int fuse_access(struct inode *inode, int mask)
{
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	struct fuse_access_in inarg;
	int err;

	if (fc->no_access)
		return 0;

953 954 955
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
M
Miklos Szeredi 已提交
956 957

	memset(&inarg, 0, sizeof(inarg));
958
	inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
M
Miklos Szeredi 已提交
959 960 961 962 963
	req->in.h.opcode = FUSE_ACCESS;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
964
	fuse_request_send(fc, req);
M
Miklos Szeredi 已提交
965 966 967 968 969 970 971 972 973
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (err == -ENOSYS) {
		fc->no_access = 1;
		err = 0;
	}
	return err;
}

974
static int fuse_perm_getattr(struct inode *inode, int mask)
975
{
976
	if (mask & MAY_NOT_BLOCK)
977 978 979 980 981
		return -ECHILD;

	return fuse_do_getattr(inode, NULL, NULL);
}

982 983 984 985 986 987 988 989 990 991 992 993 994
/*
 * Check permission.  The two basic access models of FUSE are:
 *
 * 1) Local access checking ('default_permissions' mount option) based
 * on file mode.  This is the plain old disk filesystem permission
 * modell.
 *
 * 2) "Remote" access checking, where server is responsible for
 * checking permission in each inode operation.  An exception to this
 * is if ->permission() was invoked from sys_access() in which case an
 * access request is sent.  Execute permission is still checked
 * locally based on file mode.
 */
995
static int fuse_permission(struct inode *inode, int mask)
996 997
{
	struct fuse_conn *fc = get_fuse_conn(inode);
998 999
	bool refreshed = false;
	int err = 0;
1000

1001
	if (!fuse_allow_task(fc, current))
1002
		return -EACCES;
1003 1004

	/*
1005
	 * If attributes are needed, refresh them before proceeding
1006
	 */
1007 1008
	if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
	    ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1009 1010 1011 1012 1013
		struct fuse_inode *fi = get_fuse_inode(inode);

		if (fi->i_time < get_jiffies_64()) {
			refreshed = true;

1014
			err = fuse_perm_getattr(inode, mask);
1015 1016 1017
			if (err)
				return err;
		}
1018 1019 1020
	}

	if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1021
		err = generic_permission(inode, mask);
M
Miklos Szeredi 已提交
1022 1023 1024 1025

		/* If permission is denied, try to refresh file
		   attributes.  This is also needed, because the root
		   node will at first have no permissions */
1026
		if (err == -EACCES && !refreshed) {
1027
			err = fuse_perm_getattr(inode, mask);
M
Miklos Szeredi 已提交
1028
			if (!err)
1029
				err = generic_permission(inode, mask);
M
Miklos Szeredi 已提交
1030 1031
		}

1032 1033 1034 1035
		/* Note: the opposite of the above test does not
		   exist.  So if permissions are revoked this won't be
		   noticed immediately, only after the attribute
		   timeout has expired */
E
Eric Paris 已提交
1036
	} else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1037
		if (mask & MAY_NOT_BLOCK)
1038 1039
			return -ECHILD;

1040 1041 1042 1043 1044 1045
		err = fuse_access(inode, mask);
	} else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
		if (!(inode->i_mode & S_IXUGO)) {
			if (refreshed)
				return -EACCES;

1046
			err = fuse_perm_getattr(inode, mask);
1047 1048 1049
			if (!err && !(inode->i_mode & S_IXUGO))
				return -EACCES;
		}
1050
	}
1051
	return err;
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
}

static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
			 void *dstbuf, filldir_t filldir)
{
	while (nbytes >= FUSE_NAME_OFFSET) {
		struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
		size_t reclen = FUSE_DIRENT_SIZE(dirent);
		int over;
		if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
			return -EIO;
		if (reclen > nbytes)
			break;

		over = filldir(dstbuf, dirent->name, dirent->namelen,
			       file->f_pos, dirent->ino, dirent->type);
		if (over)
			break;

		buf += reclen;
		nbytes -= reclen;
		file->f_pos = dirent->off;
	}

	return 0;
}

1079
static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1080
{
1081 1082 1083
	int err;
	size_t nbytes;
	struct page *page;
J
Josef Sipek 已提交
1084
	struct inode *inode = file->f_path.dentry->d_inode;
1085
	struct fuse_conn *fc = get_fuse_conn(inode);
1086 1087 1088 1089 1090
	struct fuse_req *req;

	if (is_bad_inode(inode))
		return -EIO;

1091 1092 1093
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1094

1095 1096 1097 1098 1099
	page = alloc_page(GFP_KERNEL);
	if (!page) {
		fuse_put_request(fc, req);
		return -ENOMEM;
	}
1100
	req->out.argpages = 1;
1101 1102
	req->num_pages = 1;
	req->pages[0] = page;
1103
	fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1104
	fuse_request_send(fc, req);
1105
	nbytes = req->out.args[0].size;
1106 1107 1108
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err)
1109 1110
		err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
				    filldir);
1111

1112
	__free_page(page);
1113
	fuse_invalidate_attr(inode); /* atime changed */
1114
	return err;
1115 1116 1117 1118 1119 1120
}

static char *read_link(struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
1121
	struct fuse_req *req = fuse_get_req(fc);
1122 1123
	char *link;

1124
	if (IS_ERR(req))
1125
		return ERR_CAST(req);
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137

	link = (char *) __get_free_page(GFP_KERNEL);
	if (!link) {
		link = ERR_PTR(-ENOMEM);
		goto out;
	}
	req->in.h.opcode = FUSE_READLINK;
	req->in.h.nodeid = get_node_id(inode);
	req->out.argvar = 1;
	req->out.numargs = 1;
	req->out.args[0].size = PAGE_SIZE - 1;
	req->out.args[0].value = link;
1138
	fuse_request_send(fc, req);
1139 1140 1141 1142 1143 1144 1145
	if (req->out.h.error) {
		free_page((unsigned long) link);
		link = ERR_PTR(req->out.h.error);
	} else
		link[req->out.args[0].size] = '\0';
 out:
	fuse_put_request(fc, req);
1146
	fuse_invalidate_attr(inode); /* atime changed */
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
	return link;
}

static void free_link(char *link)
{
	if (!IS_ERR(link))
		free_page((unsigned long) link);
}

static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
{
	nd_set_link(nd, read_link(dentry));
	return NULL;
}

static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
{
	free_link(nd_get_link(nd));
}

static int fuse_dir_open(struct inode *inode, struct file *file)
{
1169
	return fuse_open_common(inode, file, true);
1170 1171 1172 1173
}

static int fuse_dir_release(struct inode *inode, struct file *file)
{
1174 1175 1176
	fuse_release_common(file, FUSE_RELEASEDIR);

	return 0;
1177 1178
}

1179 1180
static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
			  int datasync)
1181
{
1182
	return fuse_fsync_common(file, start, end, datasync, 1);
1183 1184
}

M
Miklos Szeredi 已提交
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
static bool update_mtime(unsigned ivalid)
{
	/* Always update if mtime is explicitly set  */
	if (ivalid & ATTR_MTIME_SET)
		return true;

	/* If it's an open(O_TRUNC) or an ftruncate(), don't update */
	if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
		return false;

	/* In all other cases update */
	return true;
}

1199
static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1200 1201 1202 1203
{
	unsigned ivalid = iattr->ia_valid;

	if (ivalid & ATTR_MODE)
1204
		arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1205
	if (ivalid & ATTR_UID)
1206
		arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1207
	if (ivalid & ATTR_GID)
1208
		arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1209
	if (ivalid & ATTR_SIZE)
1210
		arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
M
Miklos Szeredi 已提交
1211 1212
	if (ivalid & ATTR_ATIME) {
		arg->valid |= FATTR_ATIME;
1213
		arg->atime = iattr->ia_atime.tv_sec;
M
Miklos Szeredi 已提交
1214 1215 1216 1217 1218 1219
		arg->atimensec = iattr->ia_atime.tv_nsec;
		if (!(ivalid & ATTR_ATIME_SET))
			arg->valid |= FATTR_ATIME_NOW;
	}
	if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
		arg->valid |= FATTR_MTIME;
1220
		arg->mtime = iattr->ia_mtime.tv_sec;
M
Miklos Szeredi 已提交
1221 1222 1223
		arg->mtimensec = iattr->ia_mtime.tv_nsec;
		if (!(ivalid & ATTR_MTIME_SET))
			arg->valid |= FATTR_MTIME_NOW;
1224
	}
1225 1226
}

M
Miklos Szeredi 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
/*
 * Prevent concurrent writepages on inode
 *
 * This is done by adding a negative bias to the inode write counter
 * and waiting for all pending writes to finish.
 */
void fuse_set_nowrite(struct inode *inode)
{
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_inode *fi = get_fuse_inode(inode);

	BUG_ON(!mutex_is_locked(&inode->i_mutex));

	spin_lock(&fc->lock);
	BUG_ON(fi->writectr < 0);
	fi->writectr += FUSE_NOWRITE;
	spin_unlock(&fc->lock);
	wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
}

/*
 * Allow writepages on inode
 *
 * Remove the bias from the writecounter and send any queued
 * writepages.
 */
static void __fuse_release_nowrite(struct inode *inode)
{
	struct fuse_inode *fi = get_fuse_inode(inode);

	BUG_ON(fi->writectr != FUSE_NOWRITE);
	fi->writectr = 0;
	fuse_flush_writepages(inode);
}

void fuse_release_nowrite(struct inode *inode)
{
	struct fuse_conn *fc = get_fuse_conn(inode);

	spin_lock(&fc->lock);
	__fuse_release_nowrite(inode);
	spin_unlock(&fc->lock);
}

1271 1272 1273 1274 1275
/*
 * Set attributes, and at the same time refresh them.
 *
 * Truncation is slightly complicated, because the 'truncate' request
 * may fail, in which case we don't want to touch the mapping.
M
Miklos Szeredi 已提交
1276 1277
 * vmtruncate() doesn't allow for this case, so do the rlimit checking
 * and the actual truncation by hand.
1278
 */
1279 1280
static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
			   struct file *file)
1281 1282 1283 1284 1285 1286
{
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	struct fuse_setattr_in inarg;
	struct fuse_attr_out outarg;
M
Miklos Szeredi 已提交
1287 1288
	bool is_truncate = false;
	loff_t oldsize;
1289 1290
	int err;

M
Miklos Szeredi 已提交
1291 1292 1293
	if (!fuse_allow_task(fc, current))
		return -EACCES;

1294 1295 1296 1297 1298 1299
	if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
		attr->ia_valid |= ATTR_FORCE;

	err = inode_change_ok(inode, attr);
	if (err)
		return err;
M
Miklos Szeredi 已提交
1300

M
Miklos Szeredi 已提交
1301 1302 1303 1304 1305
	if (attr->ia_valid & ATTR_OPEN) {
		if (fc->atomic_o_trunc)
			return 0;
		file = NULL;
	}
1306

1307
	if (attr->ia_valid & ATTR_SIZE)
M
Miklos Szeredi 已提交
1308
		is_truncate = true;
1309

1310 1311 1312
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1313

M
Miklos Szeredi 已提交
1314 1315 1316
	if (is_truncate)
		fuse_set_nowrite(inode);

1317
	memset(&inarg, 0, sizeof(inarg));
1318
	memset(&outarg, 0, sizeof(outarg));
1319
	iattr_to_fattr(attr, &inarg);
1320 1321 1322 1323 1324
	if (file) {
		struct fuse_file *ff = file->private_data;
		inarg.valid |= FATTR_FH;
		inarg.fh = ff->fh;
	}
1325 1326 1327 1328 1329
	if (attr->ia_valid & ATTR_SIZE) {
		/* For mandatory locking in truncate */
		inarg.valid |= FATTR_LOCKOWNER;
		inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
	}
1330 1331 1332 1333 1334 1335
	req->in.h.opcode = FUSE_SETATTR;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->out.numargs = 1;
1336 1337 1338 1339
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outarg);
1340
	req->out.args[0].value = &outarg;
1341
	fuse_request_send(fc, req);
1342 1343
	err = req->out.h.error;
	fuse_put_request(fc, req);
1344 1345 1346
	if (err) {
		if (err == -EINTR)
			fuse_invalidate_attr(inode);
M
Miklos Szeredi 已提交
1347
		goto error;
1348
	}
1349

1350 1351
	if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
		make_bad_inode(inode);
M
Miklos Szeredi 已提交
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
		err = -EIO;
		goto error;
	}

	spin_lock(&fc->lock);
	fuse_change_attributes_common(inode, &outarg.attr,
				      attr_timeout(&outarg));
	oldsize = inode->i_size;
	i_size_write(inode, outarg.attr.size);

	if (is_truncate) {
		/* NOTE: this may release/reacquire fc->lock */
		__fuse_release_nowrite(inode);
	}
	spin_unlock(&fc->lock);

	/*
	 * Only call invalidate_inode_pages2() after removing
	 * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
	 */
	if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
N
npiggin@suse.de 已提交
1373
		truncate_pagecache(inode, oldsize, outarg.attr.size);
M
Miklos Szeredi 已提交
1374
		invalidate_inode_pages2(inode->i_mapping);
1375 1376 1377
	}

	return 0;
M
Miklos Szeredi 已提交
1378 1379 1380 1381 1382 1383

error:
	if (is_truncate)
		fuse_release_nowrite(inode);

	return err;
1384 1385
}

1386 1387 1388 1389 1390 1391 1392 1393
static int fuse_setattr(struct dentry *entry, struct iattr *attr)
{
	if (attr->ia_valid & ATTR_FILE)
		return fuse_do_setattr(entry, attr, attr->ia_file);
	else
		return fuse_do_setattr(entry, attr, NULL);
}

1394 1395 1396 1397
static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
			struct kstat *stat)
{
	struct inode *inode = entry->d_inode;
1398 1399 1400 1401 1402
	struct fuse_conn *fc = get_fuse_conn(inode);

	if (!fuse_allow_task(fc, current))
		return -EACCES;

M
Miklos Szeredi 已提交
1403
	return fuse_update_attributes(inode, stat, NULL, NULL);
1404 1405
}

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
static int fuse_setxattr(struct dentry *entry, const char *name,
			 const void *value, size_t size, int flags)
{
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	struct fuse_setxattr_in inarg;
	int err;

	if (fc->no_setxattr)
		return -EOPNOTSUPP;

1418 1419 1420
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	inarg.flags = flags;
	req->in.h.opcode = FUSE_SETXATTR;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 3;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = strlen(name) + 1;
	req->in.args[1].value = name;
	req->in.args[2].size = size;
	req->in.args[2].value = value;
1434
	fuse_request_send(fc, req);
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (err == -ENOSYS) {
		fc->no_setxattr = 1;
		err = -EOPNOTSUPP;
	}
	return err;
}

static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
			     void *value, size_t size)
{
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	struct fuse_getxattr_in inarg;
	struct fuse_getxattr_out outarg;
	ssize_t ret;

	if (fc->no_getxattr)
		return -EOPNOTSUPP;

1457 1458 1459
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	req->in.h.opcode = FUSE_GETXATTR;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 2;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	req->in.args[1].size = strlen(name) + 1;
	req->in.args[1].value = name;
	/* This is really two different operations rolled into one */
	req->out.numargs = 1;
	if (size) {
		req->out.argvar = 1;
		req->out.args[0].size = size;
		req->out.args[0].value = value;
	} else {
		req->out.args[0].size = sizeof(outarg);
		req->out.args[0].value = &outarg;
	}
1480
	fuse_request_send(fc, req);
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
	ret = req->out.h.error;
	if (!ret)
		ret = size ? req->out.args[0].size : outarg.size;
	else {
		if (ret == -ENOSYS) {
			fc->no_getxattr = 1;
			ret = -EOPNOTSUPP;
		}
	}
	fuse_put_request(fc, req);
	return ret;
}

static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
{
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	struct fuse_getxattr_in inarg;
	struct fuse_getxattr_out outarg;
	ssize_t ret;

M
Miklos Szeredi 已提交
1503 1504 1505
	if (!fuse_allow_task(fc, current))
		return -EACCES;

1506 1507 1508
	if (fc->no_listxattr)
		return -EOPNOTSUPP;

1509 1510 1511
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529

	memset(&inarg, 0, sizeof(inarg));
	inarg.size = size;
	req->in.h.opcode = FUSE_LISTXATTR;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
	/* This is really two different operations rolled into one */
	req->out.numargs = 1;
	if (size) {
		req->out.argvar = 1;
		req->out.args[0].size = size;
		req->out.args[0].value = list;
	} else {
		req->out.args[0].size = sizeof(outarg);
		req->out.args[0].value = &outarg;
	}
1530
	fuse_request_send(fc, req);
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
	ret = req->out.h.error;
	if (!ret)
		ret = size ? req->out.args[0].size : outarg.size;
	else {
		if (ret == -ENOSYS) {
			fc->no_listxattr = 1;
			ret = -EOPNOTSUPP;
		}
	}
	fuse_put_request(fc, req);
	return ret;
}

static int fuse_removexattr(struct dentry *entry, const char *name)
{
	struct inode *inode = entry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
	struct fuse_req *req;
	int err;

	if (fc->no_removexattr)
		return -EOPNOTSUPP;

1554 1555 1556
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1557 1558 1559 1560 1561 1562

	req->in.h.opcode = FUSE_REMOVEXATTR;
	req->in.h.nodeid = get_node_id(inode);
	req->in.numargs = 1;
	req->in.args[0].size = strlen(name) + 1;
	req->in.args[0].value = name;
1563
	fuse_request_send(fc, req);
1564 1565 1566 1567 1568 1569 1570 1571 1572
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (err == -ENOSYS) {
		fc->no_removexattr = 1;
		err = -EOPNOTSUPP;
	}
	return err;
}

1573
static const struct inode_operations fuse_dir_inode_operations = {
1574
	.lookup		= fuse_lookup,
1575 1576 1577 1578 1579 1580 1581 1582 1583
	.mkdir		= fuse_mkdir,
	.symlink	= fuse_symlink,
	.unlink		= fuse_unlink,
	.rmdir		= fuse_rmdir,
	.rename		= fuse_rename,
	.link		= fuse_link,
	.setattr	= fuse_setattr,
	.create		= fuse_create,
	.mknod		= fuse_mknod,
1584 1585
	.permission	= fuse_permission,
	.getattr	= fuse_getattr,
1586 1587 1588 1589
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1590 1591
};

1592
static const struct file_operations fuse_dir_operations = {
M
Miklos Szeredi 已提交
1593
	.llseek		= generic_file_llseek,
1594 1595 1596 1597
	.read		= generic_read_dir,
	.readdir	= fuse_readdir,
	.open		= fuse_dir_open,
	.release	= fuse_dir_release,
1598
	.fsync		= fuse_dir_fsync,
1599 1600
};

1601
static const struct inode_operations fuse_common_inode_operations = {
1602
	.setattr	= fuse_setattr,
1603 1604
	.permission	= fuse_permission,
	.getattr	= fuse_getattr,
1605 1606 1607 1608
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1609 1610
};

1611
static const struct inode_operations fuse_symlink_inode_operations = {
1612
	.setattr	= fuse_setattr,
1613 1614 1615 1616
	.follow_link	= fuse_follow_link,
	.put_link	= fuse_put_link,
	.readlink	= generic_readlink,
	.getattr	= fuse_getattr,
1617 1618 1619 1620
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
};

void fuse_init_common(struct inode *inode)
{
	inode->i_op = &fuse_common_inode_operations;
}

void fuse_init_dir(struct inode *inode)
{
	inode->i_op = &fuse_dir_inode_operations;
	inode->i_fop = &fuse_dir_operations;
}

void fuse_init_symlink(struct inode *inode)
{
	inode->i_op = &fuse_symlink_inode_operations;
}