dev.c 25.5 KB
Newer Older
M
Miklos Szeredi 已提交
1 2
/*
  FUSE: Filesystem in Userspace
3
  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
M
Miklos Szeredi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

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

#include "fuse_i.h"

#include <linux/init.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/uio.h>
#include <linux/miscdevice.h>
#include <linux/pagemap.h>
#include <linux/file.h>
#include <linux/slab.h>

MODULE_ALIAS_MISCDEV(FUSE_MINOR);

static kmem_cache_t *fuse_req_cachep;

24
static struct fuse_conn *fuse_get_conn(struct file *file)
M
Miklos Szeredi 已提交
25
{
M
Miklos Szeredi 已提交
26 27 28 29 30
	/*
	 * Lockless access is OK, because file->private data is set
	 * once during mount and is valid until the file is released.
	 */
	return file->private_data;
M
Miklos Szeredi 已提交
31 32
}

33
static void fuse_request_init(struct fuse_req *req)
M
Miklos Szeredi 已提交
34 35 36
{
	memset(req, 0, sizeof(*req));
	INIT_LIST_HEAD(&req->list);
37
	INIT_LIST_HEAD(&req->intr_entry);
M
Miklos Szeredi 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
	init_waitqueue_head(&req->waitq);
	atomic_set(&req->count, 1);
}

struct fuse_req *fuse_request_alloc(void)
{
	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, SLAB_KERNEL);
	if (req)
		fuse_request_init(req);
	return req;
}

void fuse_request_free(struct fuse_req *req)
{
	kmem_cache_free(fuse_req_cachep, req);
}

55
static void block_sigs(sigset_t *oldset)
M
Miklos Szeredi 已提交
56 57 58 59 60 61 62
{
	sigset_t mask;

	siginitsetinv(&mask, sigmask(SIGKILL));
	sigprocmask(SIG_BLOCK, &mask, oldset);
}

63
static void restore_sigs(sigset_t *oldset)
M
Miklos Szeredi 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
{
	sigprocmask(SIG_SETMASK, oldset, NULL);
}

static void __fuse_get_request(struct fuse_req *req)
{
	atomic_inc(&req->count);
}

/* Must be called with > 1 refcount */
static void __fuse_put_request(struct fuse_req *req)
{
	BUG_ON(atomic_read(&req->count) < 2);
	atomic_dec(&req->count);
}

80 81 82 83 84 85 86
static void fuse_req_init_context(struct fuse_req *req)
{
	req->in.h.uid = current->fsuid;
	req->in.h.gid = current->fsgid;
	req->in.h.pid = current->pid;
}

87
struct fuse_req *fuse_get_req(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
88
{
89 90
	struct fuse_req *req;
	sigset_t oldset;
91
	int intr;
92 93
	int err;

94
	atomic_inc(&fc->num_waiting);
95
	block_sigs(&oldset);
96
	intr = wait_event_interruptible(fc->blocked_waitq, !fc->blocked);
97
	restore_sigs(&oldset);
98 99 100
	err = -EINTR;
	if (intr)
		goto out;
101

102 103 104 105
	err = -ENOTCONN;
	if (!fc->connected)
		goto out;

106
	req = fuse_request_alloc();
107
	err = -ENOMEM;
108
	if (!req)
109
		goto out;
M
Miklos Szeredi 已提交
110

111
	fuse_req_init_context(req);
112
	req->waiting = 1;
M
Miklos Szeredi 已提交
113
	return req;
114 115 116 117

 out:
	atomic_dec(&fc->num_waiting);
	return ERR_PTR(err);
M
Miklos Szeredi 已提交
118 119
}

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
/*
 * Return request in fuse_file->reserved_req.  However that may
 * currently be in use.  If that is the case, wait for it to become
 * available.
 */
static struct fuse_req *get_reserved_req(struct fuse_conn *fc,
					 struct file *file)
{
	struct fuse_req *req = NULL;
	struct fuse_file *ff = file->private_data;

	do {
		wait_event(fc->blocked_waitq, ff->reserved_req);
		spin_lock(&fc->lock);
		if (ff->reserved_req) {
			req = ff->reserved_req;
			ff->reserved_req = NULL;
			get_file(file);
			req->stolen_file = file;
		}
		spin_unlock(&fc->lock);
	} while (!req);

	return req;
}

/*
 * Put stolen request back into fuse_file->reserved_req
 */
static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req)
{
	struct file *file = req->stolen_file;
	struct fuse_file *ff = file->private_data;

	spin_lock(&fc->lock);
	fuse_request_init(req);
	BUG_ON(ff->reserved_req);
	ff->reserved_req = req;
	wake_up(&fc->blocked_waitq);
	spin_unlock(&fc->lock);
	fput(file);
}

/*
 * Gets a requests for a file operation, always succeeds
 *
 * This is used for sending the FLUSH request, which must get to
 * userspace, due to POSIX locks which may need to be unlocked.
 *
 * If allocation fails due to OOM, use the reserved request in
 * fuse_file.
 *
 * This is very unlikely to deadlock accidentally, since the
 * filesystem should not have it's own file open.  If deadlock is
 * intentional, it can still be broken by "aborting" the filesystem.
 */
struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file)
{
	struct fuse_req *req;

	atomic_inc(&fc->num_waiting);
	wait_event(fc->blocked_waitq, !fc->blocked);
	req = fuse_request_alloc();
	if (!req)
		req = get_reserved_req(fc, file);

	fuse_req_init_context(req);
	req->waiting = 1;
	return req;
}

M
Miklos Szeredi 已提交
191
void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
192 193
{
	if (atomic_dec_and_test(&req->count)) {
194 195
		if (req->waiting)
			atomic_dec(&fc->num_waiting);
196 197 198 199 200

		if (req->stolen_file)
			put_reserved_req(fc, req);
		else
			fuse_request_free(req);
201 202 203
	}
}

M
Miklos Szeredi 已提交
204 205
/*
 * This function is called when a request is finished.  Either a reply
206
 * has arrived or it was aborted (and not yet sent) or some error
M
Miklos Szeredi 已提交
207
 * occurred during communication with userspace, or the device file
208 209 210
 * was closed.  The requester thread is woken up (if still waiting),
 * the 'end' callback is called if given, else the reference to the
 * request is released
211
 *
212
 * Called with fc->lock, unlocks it
M
Miklos Szeredi 已提交
213 214 215
 */
static void request_end(struct fuse_conn *fc, struct fuse_req *req)
{
216 217
	void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
	req->end = NULL;
218
	list_del(&req->list);
219
	list_del(&req->intr_entry);
220
	req->state = FUSE_REQ_FINISHED;
221 222 223 224 225 226
	if (req->background) {
		if (fc->num_background == FUSE_MAX_BACKGROUND) {
			fc->blocked = 0;
			wake_up_all(&fc->blocked_waitq);
		}
		fc->num_background--;
M
Miklos Szeredi 已提交
227
	}
228 229 230
	spin_unlock(&fc->lock);
	dput(req->dentry);
	mntput(req->vfsmount);
M
Miklos Szeredi 已提交
231
	if (req->file)
232 233 234 235 236 237
		fput(req->file);
	wake_up(&req->waitq);
	if (end)
		end(fc, req);
	else
		fuse_put_request(fc, req);
M
Miklos Szeredi 已提交
238 239
}

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
static void wait_answer_interruptible(struct fuse_conn *fc,
				      struct fuse_req *req)
{
	if (signal_pending(current))
		return;

	spin_unlock(&fc->lock);
	wait_event_interruptible(req->waitq, req->state == FUSE_REQ_FINISHED);
	spin_lock(&fc->lock);
}

static void queue_interrupt(struct fuse_conn *fc, struct fuse_req *req)
{
	list_add_tail(&req->intr_entry, &fc->interrupts);
	wake_up(&fc->waitq);
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
}

258
/* Called with fc->lock held.  Releases, and then reacquires it. */
259
static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
260
{
261 262 263
	if (!fc->no_interrupt) {
		/* Any signal may interrupt this */
		wait_answer_interruptible(fc, req);
M
Miklos Szeredi 已提交
264

265 266 267 268 269 270 271 272 273 274 275 276
		if (req->aborted)
			goto aborted;
		if (req->state == FUSE_REQ_FINISHED)
			return;

		req->interrupted = 1;
		if (req->state == FUSE_REQ_SENT)
			queue_interrupt(fc, req);
	}

	if (req->force) {
		spin_unlock(&fc->lock);
277
		wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
278 279 280 281 282
		spin_lock(&fc->lock);
	} else {
		sigset_t oldset;

		/* Only fatal signals may interrupt this */
283
		block_sigs(&oldset);
284
		wait_answer_interruptible(fc, req);
285 286
		restore_sigs(&oldset);
	}
M
Miklos Szeredi 已提交
287

288 289 290 291 292 293 294 295 296
	if (req->aborted)
		goto aborted;
	if (req->state == FUSE_REQ_FINISHED)
 		return;

	req->out.h.error = -EINTR;
	req->aborted = 1;

 aborted:
M
Miklos Szeredi 已提交
297 298 299 300 301 302
	if (req->locked) {
		/* This is uninterruptible sleep, because data is
		   being copied to/from the buffers of req.  During
		   locked state, there mustn't be any filesystem
		   operation (e.g. page fault), since that could lead
		   to deadlock */
303
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
304
		wait_event(req->waitq, !req->locked);
305
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
306
	}
307
	if (req->state == FUSE_REQ_PENDING) {
M
Miklos Szeredi 已提交
308 309
		list_del(&req->list);
		__fuse_put_request(req);
310 311 312 313 314
	} else if (req->state == FUSE_REQ_SENT) {
		spin_unlock(&fc->lock);
		wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
		spin_lock(&fc->lock);
	}
M
Miklos Szeredi 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327
}

static unsigned len_args(unsigned numargs, struct fuse_arg *args)
{
	unsigned nbytes = 0;
	unsigned i;

	for (i = 0; i < numargs; i++)
		nbytes += args[i].size;

	return nbytes;
}

328 329 330 331 332 333 334 335 336 337
static u64 fuse_get_unique(struct fuse_conn *fc)
 {
 	fc->reqctr++;
 	/* zero is special */
 	if (fc->reqctr == 0)
 		fc->reqctr = 1;

	return fc->reqctr;
}

M
Miklos Szeredi 已提交
338 339
static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
{
340
	req->in.h.unique = fuse_get_unique(fc);
M
Miklos Szeredi 已提交
341 342 343
	req->in.h.len = sizeof(struct fuse_in_header) +
		len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
	list_add_tail(&req->list, &fc->pending);
344
	req->state = FUSE_REQ_PENDING;
345 346 347 348
	if (!req->waiting) {
		req->waiting = 1;
		atomic_inc(&fc->num_waiting);
	}
M
Miklos Szeredi 已提交
349
	wake_up(&fc->waitq);
350
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
M
Miklos Szeredi 已提交
351 352
}

353
void request_send(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
354 355
{
	req->isreply = 1;
356
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
357
	if (!fc->connected)
M
Miklos Szeredi 已提交
358 359 360 361 362 363 364 365 366
		req->out.h.error = -ENOTCONN;
	else if (fc->conn_error)
		req->out.h.error = -ECONNREFUSED;
	else {
		queue_request(fc, req);
		/* acquire extra reference, since request is still needed
		   after request_end() */
		__fuse_get_request(req);

367
		request_wait_answer(fc, req);
M
Miklos Szeredi 已提交
368
	}
369
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
370 371 372 373
}

static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
{
374
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
375
	if (fc->connected) {
376 377 378 379 380
		req->background = 1;
		fc->num_background++;
		if (fc->num_background == FUSE_MAX_BACKGROUND)
			fc->blocked = 1;

M
Miklos Szeredi 已提交
381
		queue_request(fc, req);
382
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
	} else {
		req->out.h.error = -ENOTCONN;
		request_end(fc, req);
	}
}

void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
{
	req->isreply = 0;
	request_send_nowait(fc, req);
}

void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
{
	req->isreply = 1;
	request_send_nowait(fc, req);
}

/*
 * Lock the request.  Up to the next unlock_request() there mustn't be
 * anything that could cause a page-fault.  If the request was already
404
 * aborted bail out.
M
Miklos Szeredi 已提交
405
 */
406
static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
407 408 409
{
	int err = 0;
	if (req) {
410
		spin_lock(&fc->lock);
411
		if (req->aborted)
M
Miklos Szeredi 已提交
412 413 414
			err = -ENOENT;
		else
			req->locked = 1;
415
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
416 417 418 419 420
	}
	return err;
}

/*
421
 * Unlock request.  If it was aborted during being locked, the
M
Miklos Szeredi 已提交
422 423 424
 * requester thread is currently waiting for it to be unlocked, so
 * wake it up.
 */
425
static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
426 427
{
	if (req) {
428
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
429
		req->locked = 0;
430
		if (req->aborted)
M
Miklos Szeredi 已提交
431
			wake_up(&req->waitq);
432
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
433 434 435 436
	}
}

struct fuse_copy_state {
437
	struct fuse_conn *fc;
M
Miklos Szeredi 已提交
438 439 440 441 442 443 444 445 446 447 448 449
	int write;
	struct fuse_req *req;
	const struct iovec *iov;
	unsigned long nr_segs;
	unsigned long seglen;
	unsigned long addr;
	struct page *pg;
	void *mapaddr;
	void *buf;
	unsigned len;
};

450 451 452
static void fuse_copy_init(struct fuse_copy_state *cs, struct fuse_conn *fc,
			   int write, struct fuse_req *req,
			   const struct iovec *iov, unsigned long nr_segs)
M
Miklos Szeredi 已提交
453 454
{
	memset(cs, 0, sizeof(*cs));
455
	cs->fc = fc;
M
Miklos Szeredi 已提交
456 457 458 459 460 461 462
	cs->write = write;
	cs->req = req;
	cs->iov = iov;
	cs->nr_segs = nr_segs;
}

/* Unmap and put previous page of userspace buffer */
463
static void fuse_copy_finish(struct fuse_copy_state *cs)
M
Miklos Szeredi 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
{
	if (cs->mapaddr) {
		kunmap_atomic(cs->mapaddr, KM_USER0);
		if (cs->write) {
			flush_dcache_page(cs->pg);
			set_page_dirty_lock(cs->pg);
		}
		put_page(cs->pg);
		cs->mapaddr = NULL;
	}
}

/*
 * Get another pagefull of userspace buffer, and map it to kernel
 * address space, and lock request
 */
static int fuse_copy_fill(struct fuse_copy_state *cs)
{
	unsigned long offset;
	int err;

485
	unlock_request(cs->fc, cs->req);
M
Miklos Szeredi 已提交
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
	fuse_copy_finish(cs);
	if (!cs->seglen) {
		BUG_ON(!cs->nr_segs);
		cs->seglen = cs->iov[0].iov_len;
		cs->addr = (unsigned long) cs->iov[0].iov_base;
		cs->iov ++;
		cs->nr_segs --;
	}
	down_read(&current->mm->mmap_sem);
	err = get_user_pages(current, current->mm, cs->addr, 1, cs->write, 0,
			     &cs->pg, NULL);
	up_read(&current->mm->mmap_sem);
	if (err < 0)
		return err;
	BUG_ON(err != 1);
	offset = cs->addr % PAGE_SIZE;
	cs->mapaddr = kmap_atomic(cs->pg, KM_USER0);
	cs->buf = cs->mapaddr + offset;
	cs->len = min(PAGE_SIZE - offset, cs->seglen);
	cs->seglen -= cs->len;
	cs->addr += cs->len;

508
	return lock_request(cs->fc, cs->req);
M
Miklos Szeredi 已提交
509 510 511
}

/* Do as much copy to/from userspace buffer as we can */
512
static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
M
Miklos Szeredi 已提交
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
{
	unsigned ncpy = min(*size, cs->len);
	if (val) {
		if (cs->write)
			memcpy(cs->buf, *val, ncpy);
		else
			memcpy(*val, cs->buf, ncpy);
		*val += ncpy;
	}
	*size -= ncpy;
	cs->len -= ncpy;
	cs->buf += ncpy;
	return ncpy;
}

/*
 * Copy a page in the request to/from the userspace buffer.  Must be
 * done atomically
 */
532 533
static int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
			  unsigned offset, unsigned count, int zeroing)
M
Miklos Szeredi 已提交
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
{
	if (page && zeroing && count < PAGE_SIZE) {
		void *mapaddr = kmap_atomic(page, KM_USER1);
		memset(mapaddr, 0, PAGE_SIZE);
		kunmap_atomic(mapaddr, KM_USER1);
	}
	while (count) {
		int err;
		if (!cs->len && (err = fuse_copy_fill(cs)))
			return err;
		if (page) {
			void *mapaddr = kmap_atomic(page, KM_USER1);
			void *buf = mapaddr + offset;
			offset += fuse_copy_do(cs, &buf, &count);
			kunmap_atomic(mapaddr, KM_USER1);
		} else
			offset += fuse_copy_do(cs, NULL, &count);
	}
	if (page && !cs->write)
		flush_dcache_page(page);
	return 0;
}

/* Copy pages in the request to/from userspace buffer */
static int fuse_copy_pages(struct fuse_copy_state *cs, unsigned nbytes,
			   int zeroing)
{
	unsigned i;
	struct fuse_req *req = cs->req;
	unsigned offset = req->page_offset;
	unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);

	for (i = 0; i < req->num_pages && (nbytes || zeroing); i++) {
		struct page *page = req->pages[i];
		int err = fuse_copy_page(cs, page, offset, count, zeroing);
		if (err)
			return err;

		nbytes -= count;
		count = min(nbytes, (unsigned) PAGE_SIZE);
		offset = 0;
	}
	return 0;
}

/* Copy a single argument in the request to/from userspace buffer */
static int fuse_copy_one(struct fuse_copy_state *cs, void *val, unsigned size)
{
	while (size) {
		int err;
		if (!cs->len && (err = fuse_copy_fill(cs)))
			return err;
		fuse_copy_do(cs, &val, &size);
	}
	return 0;
}

/* Copy request arguments to/from userspace buffer */
static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
			  unsigned argpages, struct fuse_arg *args,
			  int zeroing)
{
	int err = 0;
	unsigned i;

	for (i = 0; !err && i < numargs; i++)  {
		struct fuse_arg *arg = &args[i];
		if (i == numargs - 1 && argpages)
			err = fuse_copy_pages(cs, arg->size, zeroing);
		else
			err = fuse_copy_one(cs, arg->value, arg->size);
	}
	return err;
}

609 610 611 612 613
static int request_pending(struct fuse_conn *fc)
{
	return !list_empty(&fc->pending) || !list_empty(&fc->interrupts);
}

M
Miklos Szeredi 已提交
614 615 616 617 618 619
/* Wait until a request is available on the pending list */
static void request_wait(struct fuse_conn *fc)
{
	DECLARE_WAITQUEUE(wait, current);

	add_wait_queue_exclusive(&fc->waitq, &wait);
620
	while (fc->connected && !request_pending(fc)) {
M
Miklos Szeredi 已提交
621 622 623 624
		set_current_state(TASK_INTERRUPTIBLE);
		if (signal_pending(current))
			break;

625
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
626
		schedule();
627
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
628 629 630 631 632
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(&fc->waitq, &wait);
}

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
/*
 * Transfer an interrupt request to userspace
 *
 * Unlike other requests this is assembled on demand, without a need
 * to allocate a separate fuse_req structure.
 *
 * Called with fc->lock held, releases it
 */
static int fuse_read_interrupt(struct fuse_conn *fc, struct fuse_req *req,
			       const struct iovec *iov, unsigned long nr_segs)
{
	struct fuse_copy_state cs;
	struct fuse_in_header ih;
	struct fuse_interrupt_in arg;
	unsigned reqsize = sizeof(ih) + sizeof(arg);
	int err;

	list_del_init(&req->intr_entry);
	req->intr_unique = fuse_get_unique(fc);
	memset(&ih, 0, sizeof(ih));
	memset(&arg, 0, sizeof(arg));
	ih.len = reqsize;
	ih.opcode = FUSE_INTERRUPT;
	ih.unique = req->intr_unique;
	arg.unique = req->in.h.unique;

	spin_unlock(&fc->lock);
	if (iov_length(iov, nr_segs) < reqsize)
		return -EINVAL;

	fuse_copy_init(&cs, fc, 1, NULL, iov, nr_segs);
	err = fuse_copy_one(&cs, &ih, sizeof(ih));
	if (!err)
		err = fuse_copy_one(&cs, &arg, sizeof(arg));
	fuse_copy_finish(&cs);

	return err ? err : reqsize;
}

M
Miklos Szeredi 已提交
672 673 674 675
/*
 * Read a single request into the userspace filesystem's buffer.  This
 * function waits until a request is available, then removes it from
 * the pending list and copies request data to userspace buffer.  If
676 677
 * no reply is needed (FORGET) or request has been aborted or there
 * was an error during the copying then it's finished by calling
M
Miklos Szeredi 已提交
678 679 680 681 682 683 684 685 686 687 688
 * request_end().  Otherwise add it to the processing list, and set
 * the 'sent' flag.
 */
static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
			      unsigned long nr_segs, loff_t *off)
{
	int err;
	struct fuse_req *req;
	struct fuse_in *in;
	struct fuse_copy_state cs;
	unsigned reqsize;
M
Miklos Szeredi 已提交
689 690 691
	struct fuse_conn *fc = fuse_get_conn(file);
	if (!fc)
		return -EPERM;
M
Miklos Szeredi 已提交
692

693
 restart:
694
	spin_lock(&fc->lock);
695 696
	err = -EAGAIN;
	if ((file->f_flags & O_NONBLOCK) && fc->connected &&
697
	    !request_pending(fc))
698 699
		goto err_unlock;

M
Miklos Szeredi 已提交
700 701
	request_wait(fc);
	err = -ENODEV;
702
	if (!fc->connected)
M
Miklos Szeredi 已提交
703 704
		goto err_unlock;
	err = -ERESTARTSYS;
705
	if (!request_pending(fc))
M
Miklos Szeredi 已提交
706 707
		goto err_unlock;

708 709 710 711 712 713
	if (!list_empty(&fc->interrupts)) {
		req = list_entry(fc->interrupts.next, struct fuse_req,
				 intr_entry);
		return fuse_read_interrupt(fc, req, iov, nr_segs);
	}

M
Miklos Szeredi 已提交
714
	req = list_entry(fc->pending.next, struct fuse_req, list);
715
	req->state = FUSE_REQ_READING;
716
	list_move(&req->list, &fc->io);
M
Miklos Szeredi 已提交
717 718

	in = &req->in;
719 720 721 722 723 724 725 726 727
	reqsize = in->h.len;
	/* If request is too large, reply with an error and restart the read */
	if (iov_length(iov, nr_segs) < reqsize) {
		req->out.h.error = -EIO;
		/* SETXATTR is special, since it may contain too large data */
		if (in->h.opcode == FUSE_SETXATTR)
			req->out.h.error = -E2BIG;
		request_end(fc, req);
		goto restart;
M
Miklos Szeredi 已提交
728
	}
729 730
	spin_unlock(&fc->lock);
	fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
731 732 733 734
	err = fuse_copy_one(&cs, &in->h, sizeof(in->h));
	if (!err)
		err = fuse_copy_args(&cs, in->numargs, in->argpages,
				     (struct fuse_arg *) in->args, 0);
M
Miklos Szeredi 已提交
735
	fuse_copy_finish(&cs);
736
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
737
	req->locked = 0;
738
	if (!err && req->aborted)
M
Miklos Szeredi 已提交
739 740
		err = -ENOENT;
	if (err) {
741
		if (!req->aborted)
M
Miklos Szeredi 已提交
742 743 744 745 746 747 748
			req->out.h.error = -EIO;
		request_end(fc, req);
		return err;
	}
	if (!req->isreply)
		request_end(fc, req);
	else {
749
		req->state = FUSE_REQ_SENT;
750
		list_move_tail(&req->list, &fc->processing);
751 752
		if (req->interrupted)
			queue_interrupt(fc, req);
753
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
754 755 756 757
	}
	return reqsize;

 err_unlock:
758
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
	return err;
}

static ssize_t fuse_dev_read(struct file *file, char __user *buf,
			     size_t nbytes, loff_t *off)
{
	struct iovec iov;
	iov.iov_len = nbytes;
	iov.iov_base = buf;
	return fuse_dev_readv(file, &iov, 1, off);
}

/* Look up request on processing list by unique ID */
static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
{
	struct list_head *entry;

	list_for_each(entry, &fc->processing) {
		struct fuse_req *req;
		req = list_entry(entry, struct fuse_req, list);
779
		if (req->in.h.unique == unique || req->intr_unique == unique)
M
Miklos Szeredi 已提交
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
			return req;
	}
	return NULL;
}

static int copy_out_args(struct fuse_copy_state *cs, struct fuse_out *out,
			 unsigned nbytes)
{
	unsigned reqsize = sizeof(struct fuse_out_header);

	if (out->h.error)
		return nbytes != reqsize ? -EINVAL : 0;

	reqsize += len_args(out->numargs, out->args);

	if (reqsize < nbytes || (reqsize > nbytes && !out->argvar))
		return -EINVAL;
	else if (reqsize > nbytes) {
		struct fuse_arg *lastarg = &out->args[out->numargs-1];
		unsigned diffsize = reqsize - nbytes;
		if (diffsize > lastarg->size)
			return -EINVAL;
		lastarg->size -= diffsize;
	}
	return fuse_copy_args(cs, out->numargs, out->argpages, out->args,
			      out->page_zeroing);
}

/*
 * Write a single reply to a request.  First the header is copied from
 * the write buffer.  The request is then searched on the processing
 * list by the unique ID found in the header.  If found, then remove
 * it from the list and copy the rest of the buffer to the request.
 * The request is finished by calling request_end()
 */
static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
			       unsigned long nr_segs, loff_t *off)
{
	int err;
	unsigned nbytes = iov_length(iov, nr_segs);
	struct fuse_req *req;
	struct fuse_out_header oh;
	struct fuse_copy_state cs;
	struct fuse_conn *fc = fuse_get_conn(file);
	if (!fc)
825
		return -EPERM;
M
Miklos Szeredi 已提交
826

827
	fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
M
Miklos Szeredi 已提交
828 829 830 831 832 833 834 835 836 837 838
	if (nbytes < sizeof(struct fuse_out_header))
		return -EINVAL;

	err = fuse_copy_one(&cs, &oh, sizeof(oh));
	if (err)
		goto err_finish;
	err = -EINVAL;
	if (!oh.unique || oh.error <= -1000 || oh.error > 0 ||
	    oh.len != nbytes)
		goto err_finish;

839
	spin_lock(&fc->lock);
840 841 842 843
	err = -ENOENT;
	if (!fc->connected)
		goto err_unlock;

M
Miklos Szeredi 已提交
844 845 846 847
	req = request_find(fc, oh.unique);
	if (!req)
		goto err_unlock;

848
	if (req->aborted) {
849
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
850
		fuse_copy_finish(&cs);
851
		spin_lock(&fc->lock);
852
		request_end(fc, req);
M
Miklos Szeredi 已提交
853 854
		return -ENOENT;
	}
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
	/* Is it an interrupt reply? */
	if (req->intr_unique == oh.unique) {
		err = -EINVAL;
		if (nbytes != sizeof(struct fuse_out_header))
			goto err_unlock;

		if (oh.error == -ENOSYS)
			fc->no_interrupt = 1;
		else if (oh.error == -EAGAIN)
			queue_interrupt(fc, req);

		spin_unlock(&fc->lock);
		fuse_copy_finish(&cs);
		return nbytes;
	}

	req->state = FUSE_REQ_WRITING;
872
	list_move(&req->list, &fc->io);
M
Miklos Szeredi 已提交
873 874 875
	req->out.h = oh;
	req->locked = 1;
	cs.req = req;
876
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
877 878 879 880

	err = copy_out_args(&cs, &req->out, nbytes);
	fuse_copy_finish(&cs);

881
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
882 883
	req->locked = 0;
	if (!err) {
884
		if (req->aborted)
M
Miklos Szeredi 已提交
885
			err = -ENOENT;
886
	} else if (!req->aborted)
M
Miklos Szeredi 已提交
887 888 889 890 891 892
		req->out.h.error = -EIO;
	request_end(fc, req);

	return err ? err : nbytes;

 err_unlock:
893
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
 err_finish:
	fuse_copy_finish(&cs);
	return err;
}

static ssize_t fuse_dev_write(struct file *file, const char __user *buf,
			      size_t nbytes, loff_t *off)
{
	struct iovec iov;
	iov.iov_len = nbytes;
	iov.iov_base = (char __user *) buf;
	return fuse_dev_writev(file, &iov, 1, off);
}

static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
{
	unsigned mask = POLLOUT | POLLWRNORM;
911
	struct fuse_conn *fc = fuse_get_conn(file);
M
Miklos Szeredi 已提交
912
	if (!fc)
913
		return POLLERR;
M
Miklos Szeredi 已提交
914 915 916

	poll_wait(file, &fc->waitq, wait);

917
	spin_lock(&fc->lock);
918 919
	if (!fc->connected)
		mask = POLLERR;
920
	else if (request_pending(fc))
921
		mask |= POLLIN | POLLRDNORM;
922
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
923 924 925 926

	return mask;
}

927 928 929
/*
 * Abort all requests on the given list (pending or processing)
 *
930
 * This function releases and reacquires fc->lock
931
 */
M
Miklos Szeredi 已提交
932 933 934 935 936 937 938
static void end_requests(struct fuse_conn *fc, struct list_head *head)
{
	while (!list_empty(head)) {
		struct fuse_req *req;
		req = list_entry(head->next, struct fuse_req, list);
		req->out.h.error = -ECONNABORTED;
		request_end(fc, req);
939
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
940 941 942
	}
}

943 944 945
/*
 * Abort requests under I/O
 *
946
 * The requests are set to aborted and finished, and the request
947 948
 * waiter is woken up.  This will make request_wait_answer() wait
 * until the request is unlocked and then return.
949 950 951 952
 *
 * If the request is asynchronous, then the end function needs to be
 * called after waiting for the request to be unlocked (if it was
 * locked).
953 954 955 956
 */
static void end_io_requests(struct fuse_conn *fc)
{
	while (!list_empty(&fc->io)) {
957 958 959 960
		struct fuse_req *req =
			list_entry(fc->io.next, struct fuse_req, list);
		void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;

961
		req->aborted = 1;
962 963 964 965
		req->out.h.error = -ECONNABORTED;
		req->state = FUSE_REQ_FINISHED;
		list_del_init(&req->list);
		wake_up(&req->waitq);
966 967 968 969
		if (end) {
			req->end = NULL;
			/* The end function will consume this reference */
			__fuse_get_request(req);
970
			spin_unlock(&fc->lock);
971 972
			wait_event(req->waitq, !req->locked);
			end(fc, req);
973
			spin_lock(&fc->lock);
974
		}
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
	}
}

/*
 * Abort all requests.
 *
 * Emergency exit in case of a malicious or accidental deadlock, or
 * just a hung filesystem.
 *
 * The same effect is usually achievable through killing the
 * filesystem daemon and all users of the filesystem.  The exception
 * is the combination of an asynchronous request and the tricky
 * deadlock (see Documentation/filesystems/fuse.txt).
 *
 * During the aborting, progression of requests from the pending and
 * processing lists onto the io list, and progression of new requests
 * onto the pending list is prevented by req->connected being false.
 *
 * Progression of requests under I/O to the processing list is
994 995
 * prevented by the req->aborted flag being true for these requests.
 * For this reason requests on the io list must be aborted first.
996 997 998
 */
void fuse_abort_conn(struct fuse_conn *fc)
{
999
	spin_lock(&fc->lock);
1000 1001
	if (fc->connected) {
		fc->connected = 0;
1002
		fc->blocked = 0;
1003 1004 1005 1006
		end_io_requests(fc);
		end_requests(fc, &fc->pending);
		end_requests(fc, &fc->processing);
		wake_up_all(&fc->waitq);
1007
		wake_up_all(&fc->blocked_waitq);
1008
		kill_fasync(&fc->fasync, SIGIO, POLL_IN);
1009
	}
1010
	spin_unlock(&fc->lock);
1011 1012
}

M
Miklos Szeredi 已提交
1013 1014
static int fuse_dev_release(struct inode *inode, struct file *file)
{
M
Miklos Szeredi 已提交
1015
	struct fuse_conn *fc = fuse_get_conn(file);
M
Miklos Szeredi 已提交
1016
	if (fc) {
1017
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
1018
		fc->connected = 0;
M
Miklos Szeredi 已提交
1019 1020
		end_requests(fc, &fc->pending);
		end_requests(fc, &fc->processing);
1021
		spin_unlock(&fc->lock);
1022
		fasync_helper(-1, file, 0, &fc->fasync);
1023
		fuse_conn_put(fc);
1024
	}
1025

M
Miklos Szeredi 已提交
1026 1027 1028
	return 0;
}

1029 1030 1031 1032
static int fuse_dev_fasync(int fd, struct file *file, int on)
{
	struct fuse_conn *fc = fuse_get_conn(file);
	if (!fc)
1033
		return -EPERM;
1034 1035 1036 1037 1038

	/* No locking - fasync_helper does its own locking */
	return fasync_helper(fd, file, on, &fc->fasync);
}

1039
const struct file_operations fuse_dev_operations = {
M
Miklos Szeredi 已提交
1040 1041 1042 1043 1044 1045 1046 1047
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= fuse_dev_read,
	.readv		= fuse_dev_readv,
	.write		= fuse_dev_write,
	.writev		= fuse_dev_writev,
	.poll		= fuse_dev_poll,
	.release	= fuse_dev_release,
1048
	.fasync		= fuse_dev_fasync,
M
Miklos Szeredi 已提交
1049 1050 1051 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 1079 1080 1081 1082
};

static struct miscdevice fuse_miscdevice = {
	.minor = FUSE_MINOR,
	.name  = "fuse",
	.fops = &fuse_dev_operations,
};

int __init fuse_dev_init(void)
{
	int err = -ENOMEM;
	fuse_req_cachep = kmem_cache_create("fuse_request",
					    sizeof(struct fuse_req),
					    0, 0, NULL, NULL);
	if (!fuse_req_cachep)
		goto out;

	err = misc_register(&fuse_miscdevice);
	if (err)
		goto out_cache_clean;

	return 0;

 out_cache_clean:
	kmem_cache_destroy(fuse_req_cachep);
 out:
	return err;
}

void fuse_dev_cleanup(void)
{
	misc_deregister(&fuse_miscdevice);
	kmem_cache_destroy(fuse_req_cachep);
}