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

  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/gfp.h>
#include <linux/sched.h>
#include <linux/namei.h>

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 160 161
	struct inode *inode = entry->d_inode;

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

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

		fc = get_fuse_conn(inode);
177 178
		req = fuse_get_req(fc);
		if (IS_ERR(req))
179 180
			return 0;

M
Miklos Szeredi 已提交
181 182 183 184 185 186
		forget_req = fuse_get_req(fc);
		if (IS_ERR(forget_req)) {
			fuse_put_request(fc, req);
			return 0;
		}

187
		attr_version = fuse_get_attr_version(fc);
188

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

214 215 216 217
		fuse_change_attributes(inode, &outarg.attr,
				       entry_attr_timeout(&outarg),
				       attr_version);
		fuse_change_entry_timeout(entry, &outarg);
218 219 220 221
	}
	return 1;
}

222
static int invalid_nodeid(u64 nodeid)
223 224 225 226
{
	return !nodeid || nodeid == FUSE_ROOT_ID;
}

M
Miklos Szeredi 已提交
227
struct dentry_operations fuse_dentry_operations = {
228 229 230
	.d_revalidate	= fuse_dentry_revalidate,
};

231
int fuse_valid_type(int m)
232 233 234 235 236
{
	return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
		S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
}

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

257 258
int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
		     struct fuse_entry_out *outarg, struct inode **inode)
259
{
260
	struct fuse_conn *fc = get_fuse_conn_super(sb);
261
	struct fuse_req *req;
M
Miklos Szeredi 已提交
262
	struct fuse_req *forget_req;
263
	u64 attr_version;
264
	int err;
265

266 267 268 269
	*inode = NULL;
	err = -ENAMETOOLONG;
	if (name->len > FUSE_NAME_MAX)
		goto out;
270

271
	req = fuse_get_req(fc);
272
	err = PTR_ERR(req);
273
	if (IS_ERR(req))
274
		goto out;
275

M
Miklos Szeredi 已提交
276
	forget_req = fuse_get_req(fc);
277
	err = PTR_ERR(forget_req);
M
Miklos Szeredi 已提交
278 279
	if (IS_ERR(forget_req)) {
		fuse_put_request(fc, req);
280
		goto out;
M
Miklos Szeredi 已提交
281 282
	}

283
	attr_version = fuse_get_attr_version(fc);
284

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

 out_put_forget:
M
Miklos Szeredi 已提交
310
	fuse_put_request(fc, forget_req);
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
 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;
337

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

349
	entry = newent ? newent : entry;
350
	entry->d_op = &fuse_dentry_operations;
351
	if (outarg_valid)
352
		fuse_change_entry_timeout(entry, &outarg);
353 354
	else
		fuse_invalidate_entry_cache(entry);
355

356
	return newent;
357 358 359 360 361

 out_iput:
	iput(inode);
 out_err:
	return ERR_PTR(err);
362 363
}

364 365 366 367 368 369
/*
 * Synchronous release for the case when something goes wrong in CREATE_OPEN
 */
static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
			      u64 nodeid, int flags)
{
370 371 372 373 374
	fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
	ff->reserved_req->force = 1;
	request_send(fc, ff->reserved_req);
	fuse_put_request(fc, ff->reserved_req);
	kfree(ff);
375 376
}

377 378 379 380 381 382
/*
 * Atomic create+open operation
 *
 * If the filesystem doesn't support this, then fall back to separate
 * 'mknod' + 'open' requests.
 */
M
Miklos Szeredi 已提交
383 384 385 386 387 388 389
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;
390
	struct fuse_req *forget_req;
M
Miklos Szeredi 已提交
391 392 393 394 395 396 397 398
	struct fuse_open_in inarg;
	struct fuse_open_out outopen;
	struct fuse_entry_out outentry;
	struct fuse_file *ff;
	struct file *file;
	int flags = nd->intent.open.flags - 1;

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

401 402 403 404
	forget_req = fuse_get_req(fc);
	if (IS_ERR(forget_req))
		return PTR_ERR(forget_req);

405
	req = fuse_get_req(fc);
406
	err = PTR_ERR(req);
407
	if (IS_ERR(req))
408
		goto out_put_forget_req;
M
Miklos Szeredi 已提交
409

410
	err = -ENOMEM;
M
Miklos Szeredi 已提交
411 412 413 414 415 416
	ff = fuse_file_alloc();
	if (!ff)
		goto out_put_request;

	flags &= ~O_NOCTTY;
	memset(&inarg, 0, sizeof(inarg));
417
	memset(&outentry, 0, sizeof(outentry));
M
Miklos Szeredi 已提交
418 419 420 421 422 423 424 425 426 427
	inarg.flags = flags;
	inarg.mode = mode;
	req->in.h.opcode = FUSE_CREATE;
	req->in.h.nodeid = get_node_id(dir);
	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;
	req->out.numargs = 2;
428 429 430 431
	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 已提交
432 433 434 435 436 437 438 439 440 441 442 443
	req->out.args[0].value = &outentry;
	req->out.args[1].size = sizeof(outopen);
	req->out.args[1].value = &outopen;
	request_send(fc, req);
	err = req->out.h.error;
	if (err) {
		if (err == -ENOSYS)
			fc->no_create = 1;
		goto out_free_ff;
	}

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

447
	fuse_put_request(fc, req);
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 452
	if (!inode) {
		flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
		ff->fh = outopen.fh;
453 454 455
		fuse_sync_release(fc, ff, outentry.nodeid, flags);
		fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
		return -ENOMEM;
M
Miklos Szeredi 已提交
456
	}
457
	fuse_put_request(fc, forget_req);
M
Miklos Szeredi 已提交
458
	d_instantiate(entry, inode);
459
	fuse_change_entry_timeout(entry, &outentry);
460
	fuse_invalidate_attr(dir);
M
Miklos Szeredi 已提交
461 462 463
	file = lookup_instantiate_filp(nd, entry, generic_file_open);
	if (IS_ERR(file)) {
		ff->fh = outopen.fh;
464
		fuse_sync_release(fc, ff, outentry.nodeid, flags);
M
Miklos Szeredi 已提交
465 466 467 468 469 470 471 472 473
		return PTR_ERR(file);
	}
	fuse_finish_open(inode, file, ff, &outopen);
	return 0;

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

479 480 481
/*
 * Code shared between mknod, mkdir, symlink and link
 */
482 483 484 485 486 487 488
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;
M
Miklos Szeredi 已提交
489 490 491 492 493 494 495
	struct fuse_req *forget_req;

	forget_req = fuse_get_req(fc);
	if (IS_ERR(forget_req)) {
		fuse_put_request(fc, req);
		return PTR_ERR(forget_req);
	}
496

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

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

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

518
	inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
519
			  &outarg.attr, entry_attr_timeout(&outarg), 0);
520
	if (!inode) {
M
Miklos Szeredi 已提交
521
		fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
522 523
		return -ENOMEM;
	}
M
Miklos Szeredi 已提交
524
	fuse_put_request(fc, forget_req);
525

526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	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);
541

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

M
Miklos Szeredi 已提交
546 547
 out_put_forget_req:
	fuse_put_request(fc, forget_req);
548
	return err;
549 550 551 552 553 554 555
}

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);
556 557 558
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
	inarg.rdev = new_encode_dev(rdev);
	req->in.h.opcode = FUSE_MKNOD;
	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, mode);
}

static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
		       struct nameidata *nd)
{
M
Miklos Szeredi 已提交
575
	if (nd && (nd->flags & LOOKUP_OPEN)) {
M
Miklos Szeredi 已提交
576 577 578 579 580
		int err = fuse_create_open(dir, entry, mode, nd);
		if (err != -ENOSYS)
			return err;
		/* Fall back on mknod */
	}
581 582 583 584 585 586 587
	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);
588 589 590
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

	memset(&inarg, 0, sizeof(inarg));
	inarg.mode = mode;
	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;
608 609 610
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
611 612 613 614 615 616 617 618 619 620 621 622 623 624

	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);
625 626 627
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642

	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;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
		struct inode *inode = entry->d_inode;

		/* 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 */
643
		clear_nlink(inode);
644 645
		fuse_invalidate_attr(inode);
		fuse_invalidate_attr(dir);
646
		fuse_invalidate_entry_cache(entry);
647 648 649 650 651 652 653 654 655
	} 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);
656 657 658
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
659 660 661 662 663 664 665 666 667 668

	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;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
669
		clear_nlink(entry->d_inode);
670
		fuse_invalidate_attr(dir);
671
		fuse_invalidate_entry_cache(entry);
672 673 674 675 676 677 678 679 680 681 682
	} 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);
683 684 685
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701

	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;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
702 703 704
		/* ctime changes */
		fuse_invalidate_attr(oldent->d_inode);

705 706 707
		fuse_invalidate_attr(olddir);
		if (olddir != newdir)
			fuse_invalidate_attr(newdir);
708 709 710 711

		/* newent will end up negative */
		if (newent->d_inode)
			fuse_invalidate_entry_cache(newent);
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
	} 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);
733 734 735
	struct fuse_req *req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756

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

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
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);
}

778 779
static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
			   struct file *file)
780 781
{
	int err;
782 783
	struct fuse_getattr_in inarg;
	struct fuse_attr_out outarg;
784
	struct fuse_conn *fc = get_fuse_conn(inode);
785 786 787 788
	struct fuse_req *req;
	u64 attr_version;

	req = fuse_get_req(fc);
789 790
	if (IS_ERR(req))
		return PTR_ERR(req);
791

792
	attr_version = fuse_get_attr_version(fc);
793

794
	memset(&inarg, 0, sizeof(inarg));
795
	memset(&outarg, 0, sizeof(outarg));
796 797 798 799 800 801 802
	/* 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;
	}
803 804
	req->in.h.opcode = FUSE_GETATTR;
	req->in.h.nodeid = get_node_id(inode);
805 806 807
	req->in.numargs = 1;
	req->in.args[0].size = sizeof(inarg);
	req->in.args[0].value = &inarg;
808
	req->out.numargs = 1;
809 810 811 812
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outarg);
813
	req->out.args[0].value = &outarg;
814 815 816 817
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err) {
818
		if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
819 820 821
			make_bad_inode(inode);
			err = -EIO;
		} else {
822 823
			fuse_change_attributes(inode, &outarg.attr,
					       attr_timeout(&outarg),
824 825
					       attr_version);
			if (stat)
826
				fuse_fillattr(inode, &outarg.attr, stat);
827 828 829 830 831
		}
	}
	return err;
}

M
Miklos Szeredi 已提交
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
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;
}

857 858 859 860 861 862 863 864 865 866 867 868 869
/*
 * 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 已提交
870
int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
{
	if (fc->flags & FUSE_ALLOW_OTHER)
		return 1;

	if (task->euid == fc->user_id &&
	    task->suid == fc->user_id &&
	    task->uid == fc->user_id &&
	    task->egid == fc->group_id &&
	    task->sgid == fc->group_id &&
	    task->gid == fc->group_id)
		return 1;

	return 0;
}

M
Miklos Szeredi 已提交
886 887 888 889 890 891 892 893 894 895
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;

896 897 898
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
M
Miklos Szeredi 已提交
899 900

	memset(&inarg, 0, sizeof(inarg));
901
	inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
M
Miklos Szeredi 已提交
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
	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;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (err == -ENOSYS) {
		fc->no_access = 1;
		err = 0;
	}
	return err;
}

917 918 919 920 921 922 923 924 925 926 927 928 929
/*
 * 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.
 */
930
static int fuse_permission(struct inode *inode, int mask)
931 932
{
	struct fuse_conn *fc = get_fuse_conn(inode);
933 934
	bool refreshed = false;
	int err = 0;
935

936
	if (!fuse_allow_task(fc, current))
937
		return -EACCES;
938 939

	/*
940
	 * If attributes are needed, refresh them before proceeding
941
	 */
942 943
	if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
	    ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
M
Miklos Szeredi 已提交
944 945 946
		err = fuse_update_attributes(inode, NULL, NULL, &refreshed);
		if (err)
			return err;
947 948 949
	}

	if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
M
Miklos Szeredi 已提交
950
		err = generic_permission(inode, mask, NULL);
M
Miklos Szeredi 已提交
951 952 953 954

		/* If permission is denied, try to refresh file
		   attributes.  This is also needed, because the root
		   node will at first have no permissions */
955
		if (err == -EACCES && !refreshed) {
956
			err = fuse_do_getattr(inode, NULL, NULL);
M
Miklos Szeredi 已提交
957 958 959 960
			if (!err)
				err = generic_permission(inode, mask, NULL);
		}

961 962 963 964
		/* 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 */
965
	} else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
966 967 968 969 970 971
		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;

972
			err = fuse_do_getattr(inode, NULL, NULL);
973 974 975
			if (!err && !(inode->i_mode & S_IXUGO))
				return -EACCES;
		}
976
	}
977
	return err;
978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
}

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

1005
static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1006
{
1007 1008 1009
	int err;
	size_t nbytes;
	struct page *page;
J
Josef Sipek 已提交
1010
	struct inode *inode = file->f_path.dentry->d_inode;
1011
	struct fuse_conn *fc = get_fuse_conn(inode);
1012 1013 1014 1015 1016
	struct fuse_req *req;

	if (is_bad_inode(inode))
		return -EIO;

1017 1018 1019
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1020

1021 1022 1023 1024 1025 1026 1027
	page = alloc_page(GFP_KERNEL);
	if (!page) {
		fuse_put_request(fc, req);
		return -ENOMEM;
	}
	req->num_pages = 1;
	req->pages[0] = page;
1028
	fuse_read_fill(req, file, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1029 1030
	request_send(fc, req);
	nbytes = req->out.args[0].size;
1031 1032 1033
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (!err)
1034 1035
		err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
				    filldir);
1036

1037
	__free_page(page);
1038
	fuse_invalidate_attr(inode); /* atime changed */
1039
	return err;
1040 1041 1042 1043 1044 1045
}

static char *read_link(struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;
	struct fuse_conn *fc = get_fuse_conn(inode);
1046
	struct fuse_req *req = fuse_get_req(fc);
1047 1048
	char *link;

1049
	if (IS_ERR(req))
1050
		return ERR_CAST(req);
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070

	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;
	request_send(fc, req);
	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);
1071
	fuse_invalidate_attr(inode); /* atime changed */
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	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)
{
1094
	return fuse_open_common(inode, file, 1);
1095 1096 1097 1098
}

static int fuse_dir_release(struct inode *inode, struct file *file)
{
1099
	return fuse_release_common(inode, file, 1);
1100 1101
}

1102 1103 1104 1105 1106 1107
static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
{
	/* nfsd can call this with no file */
	return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
}

M
Miklos Szeredi 已提交
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
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;
}

1122
static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1123 1124 1125 1126
{
	unsigned ivalid = iattr->ia_valid;

	if (ivalid & ATTR_MODE)
1127
		arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1128
	if (ivalid & ATTR_UID)
1129
		arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1130
	if (ivalid & ATTR_GID)
1131
		arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1132
	if (ivalid & ATTR_SIZE)
1133
		arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
M
Miklos Szeredi 已提交
1134 1135
	if (ivalid & ATTR_ATIME) {
		arg->valid |= FATTR_ATIME;
1136
		arg->atime = iattr->ia_atime.tv_sec;
M
Miklos Szeredi 已提交
1137 1138 1139 1140 1141 1142
		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;
1143
		arg->mtime = iattr->ia_mtime.tv_sec;
M
Miklos Szeredi 已提交
1144 1145 1146
		arg->mtimensec = iattr->ia_mtime.tv_nsec;
		if (!(ivalid & ATTR_MTIME_SET))
			arg->valid |= FATTR_MTIME_NOW;
1147
	}
1148 1149
}

M
Miklos Szeredi 已提交
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
/*
 * 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);
}

1194 1195 1196 1197 1198
/*
 * 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 已提交
1199 1200
 * vmtruncate() doesn't allow for this case, so do the rlimit checking
 * and the actual truncation by hand.
1201
 */
1202 1203
static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
			   struct file *file)
1204 1205 1206 1207 1208 1209
{
	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 已提交
1210 1211
	bool is_truncate = false;
	loff_t oldsize;
1212 1213
	int err;

M
Miklos Szeredi 已提交
1214 1215 1216
	if (!fuse_allow_task(fc, current))
		return -EACCES;

M
Miklos Szeredi 已提交
1217 1218 1219 1220 1221 1222
	if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
		err = inode_change_ok(inode, attr);
		if (err)
			return err;
	}

1223 1224 1225
	if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
		return 0;

1226 1227
	if (attr->ia_valid & ATTR_SIZE) {
		unsigned long limit;
M
Miklos Szeredi 已提交
1228 1229
		if (IS_SWAPFILE(inode))
			return -ETXTBSY;
1230 1231 1232 1233 1234
		limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
		if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
			send_sig(SIGXFSZ, current, 0);
			return -EFBIG;
		}
M
Miklos Szeredi 已提交
1235
		is_truncate = true;
1236 1237
	}

1238 1239 1240
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1241

M
Miklos Szeredi 已提交
1242 1243 1244
	if (is_truncate)
		fuse_set_nowrite(inode);

1245
	memset(&inarg, 0, sizeof(inarg));
1246
	memset(&outarg, 0, sizeof(outarg));
1247
	iattr_to_fattr(attr, &inarg);
1248 1249 1250 1251 1252
	if (file) {
		struct fuse_file *ff = file->private_data;
		inarg.valid |= FATTR_FH;
		inarg.fh = ff->fh;
	}
1253 1254 1255 1256 1257
	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);
	}
1258 1259 1260 1261 1262 1263
	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;
1264 1265 1266 1267
	if (fc->minor < 9)
		req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
	else
		req->out.args[0].size = sizeof(outarg);
1268 1269 1270 1271
	req->out.args[0].value = &outarg;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
1272 1273 1274
	if (err) {
		if (err == -EINTR)
			fuse_invalidate_attr(inode);
M
Miklos Szeredi 已提交
1275
		goto error;
1276
	}
1277

1278 1279
	if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
		make_bad_inode(inode);
M
Miklos Szeredi 已提交
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
		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) {
		if (outarg.attr.size < oldsize)
			fuse_truncate(inode->i_mapping, outarg.attr.size);
		invalidate_inode_pages2(inode->i_mapping);
1304 1305 1306
	}

	return 0;
M
Miklos Szeredi 已提交
1307 1308 1309 1310 1311 1312

error:
	if (is_truncate)
		fuse_release_nowrite(inode);

	return err;
1313 1314
}

1315 1316 1317 1318 1319 1320 1321 1322
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);
}

1323 1324 1325 1326
static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
			struct kstat *stat)
{
	struct inode *inode = entry->d_inode;
1327 1328 1329 1330 1331
	struct fuse_conn *fc = get_fuse_conn(inode);

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

M
Miklos Szeredi 已提交
1332
	return fuse_update_attributes(inode, stat, NULL, NULL);
1333 1334
}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
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;

1347 1348 1349
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385

	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;
	request_send(fc, req);
	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;

1386 1387 1388
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431

	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;
	}
	request_send(fc, req);
	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 已提交
1432 1433 1434
	if (!fuse_allow_task(fc, current))
		return -EACCES;

1435 1436 1437
	if (fc->no_listxattr)
		return -EOPNOTSUPP;

1438 1439 1440
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482

	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;
	}
	request_send(fc, req);
	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;

1483 1484 1485
	req = fuse_get_req(fc);
	if (IS_ERR(req))
		return PTR_ERR(req);
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501

	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;
	request_send(fc, req);
	err = req->out.h.error;
	fuse_put_request(fc, req);
	if (err == -ENOSYS) {
		fc->no_removexattr = 1;
		err = -EOPNOTSUPP;
	}
	return err;
}

1502
static const struct inode_operations fuse_dir_inode_operations = {
1503
	.lookup		= fuse_lookup,
1504 1505 1506 1507 1508 1509 1510 1511 1512
	.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,
1513 1514
	.permission	= fuse_permission,
	.getattr	= fuse_getattr,
1515 1516 1517 1518
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1519 1520
};

1521
static const struct file_operations fuse_dir_operations = {
M
Miklos Szeredi 已提交
1522
	.llseek		= generic_file_llseek,
1523 1524 1525 1526
	.read		= generic_read_dir,
	.readdir	= fuse_readdir,
	.open		= fuse_dir_open,
	.release	= fuse_dir_release,
1527
	.fsync		= fuse_dir_fsync,
1528 1529
};

1530
static const struct inode_operations fuse_common_inode_operations = {
1531
	.setattr	= fuse_setattr,
1532 1533
	.permission	= fuse_permission,
	.getattr	= fuse_getattr,
1534 1535 1536 1537
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1538 1539
};

1540
static const struct inode_operations fuse_symlink_inode_operations = {
1541
	.setattr	= fuse_setattr,
1542 1543 1544 1545
	.follow_link	= fuse_follow_link,
	.put_link	= fuse_put_link,
	.readlink	= generic_readlink,
	.getattr	= fuse_getattr,
1546 1547 1548 1549
	.setxattr	= fuse_setxattr,
	.getxattr	= fuse_getxattr,
	.listxattr	= fuse_listxattr,
	.removexattr	= fuse_removexattr,
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
};

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