dev.c 29.2 KB
Newer Older
M
Miklos Szeredi 已提交
1 2
/*
  FUSE: Filesystem in Userspace
M
Miklos Szeredi 已提交
3
  Copyright (C) 2001-2008  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

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

22
static struct kmem_cache *fuse_req_cachep;
M
Miklos Szeredi 已提交
23

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
	init_waitqueue_head(&req->waitq);
	atomic_set(&req->count, 1);
}

struct fuse_req *fuse_request_alloc(void)
{
44
	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_KERNEL);
M
Miklos Szeredi 已提交
45 46 47 48
	if (req)
		fuse_request_init(req);
	return req;
}
49
EXPORT_SYMBOL_GPL(fuse_request_alloc);
M
Miklos Szeredi 已提交
50

M
Miklos Szeredi 已提交
51 52 53 54 55 56 57 58
struct fuse_req *fuse_request_alloc_nofs(void)
{
	struct fuse_req *req = kmem_cache_alloc(fuse_req_cachep, GFP_NOFS);
	if (req)
		fuse_request_init(req);
	return req;
}

M
Miklos Szeredi 已提交
59 60 61 62 63
void fuse_request_free(struct fuse_req *req)
{
	kmem_cache_free(fuse_req_cachep, req);
}

64
static void block_sigs(sigset_t *oldset)
M
Miklos Szeredi 已提交
65 66 67 68 69 70 71
{
	sigset_t mask;

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

72
static void restore_sigs(sigset_t *oldset)
M
Miklos Szeredi 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
{
	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);
}

89 90
static void fuse_req_init_context(struct fuse_req *req)
{
91 92
	req->in.h.uid = current_fsuid();
	req->in.h.gid = current_fsgid();
93 94 95
	req->in.h.pid = current->pid;
}

96
struct fuse_req *fuse_get_req(struct fuse_conn *fc)
M
Miklos Szeredi 已提交
97
{
98 99
	struct fuse_req *req;
	sigset_t oldset;
100
	int intr;
101 102
	int err;

103
	atomic_inc(&fc->num_waiting);
104
	block_sigs(&oldset);
105
	intr = wait_event_interruptible(fc->blocked_waitq, !fc->blocked);
106
	restore_sigs(&oldset);
107 108 109
	err = -EINTR;
	if (intr)
		goto out;
110

111 112 113 114
	err = -ENOTCONN;
	if (!fc->connected)
		goto out;

115
	req = fuse_request_alloc();
116
	err = -ENOMEM;
117
	if (!req)
118
		goto out;
M
Miklos Szeredi 已提交
119

120
	fuse_req_init_context(req);
121
	req->waiting = 1;
M
Miklos Szeredi 已提交
122
	return req;
123 124 125 126

 out:
	atomic_dec(&fc->num_waiting);
	return ERR_PTR(err);
M
Miklos Szeredi 已提交
127
}
128
EXPORT_SYMBOL_GPL(fuse_get_req);
M
Miklos Szeredi 已提交
129

130 131 132 133 134 135 136 137 138 139 140 141
/*
 * 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 {
142
		wait_event(fc->reserved_req_waitq, ff->reserved_req);
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
		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;
168
	wake_up_all(&fc->reserved_req_waitq);
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
	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 已提交
201
void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
202 203
{
	if (atomic_dec_and_test(&req->count)) {
204 205
		if (req->waiting)
			atomic_dec(&fc->num_waiting);
206 207 208 209 210

		if (req->stolen_file)
			put_reserved_req(fc, req);
		else
			fuse_request_free(req);
211 212
	}
}
213
EXPORT_SYMBOL_GPL(fuse_put_request);
214

215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
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;
}

static u64 fuse_get_unique(struct fuse_conn *fc)
{
	fc->reqctr++;
	/* zero is special */
	if (fc->reqctr == 0)
		fc->reqctr = 1;

	return fc->reqctr;
}

static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
{
	req->in.h.unique = fuse_get_unique(fc);
	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);
	req->state = FUSE_REQ_PENDING;
	if (!req->waiting) {
		req->waiting = 1;
		atomic_inc(&fc->num_waiting);
	}
	wake_up(&fc->waitq);
	kill_fasync(&fc->fasync, SIGIO, POLL_IN);
}

static void flush_bg_queue(struct fuse_conn *fc)
{
253
	while (fc->active_background < fc->max_background &&
254 255 256 257 258 259 260 261 262 263
	       !list_empty(&fc->bg_queue)) {
		struct fuse_req *req;

		req = list_entry(fc->bg_queue.next, struct fuse_req, list);
		list_del(&req->list);
		fc->active_background++;
		queue_request(fc, req);
	}
}

M
Miklos Szeredi 已提交
264 265
/*
 * This function is called when a request is finished.  Either a reply
266
 * has arrived or it was aborted (and not yet sent) or some error
M
Miklos Szeredi 已提交
267
 * occurred during communication with userspace, or the device file
268 269 270
 * 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
271
 *
272
 * Called with fc->lock, unlocks it
M
Miklos Szeredi 已提交
273 274
 */
static void request_end(struct fuse_conn *fc, struct fuse_req *req)
275
__releases(&fc->lock)
M
Miklos Szeredi 已提交
276
{
277 278
	void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
	req->end = NULL;
279
	list_del(&req->list);
280
	list_del(&req->intr_entry);
281
	req->state = FUSE_REQ_FINISHED;
282
	if (req->background) {
283
		if (fc->num_background == fc->max_background) {
284 285 286
			fc->blocked = 0;
			wake_up_all(&fc->blocked_waitq);
		}
287
		if (fc->num_background == fc->congestion_threshold &&
288
		    fc->connected && fc->bdi_initialized) {
289 290
			clear_bdi_congested(&fc->bdi, BLK_RW_SYNC);
			clear_bdi_congested(&fc->bdi, BLK_RW_ASYNC);
291
		}
292
		fc->num_background--;
293 294
		fc->active_background--;
		flush_bg_queue(fc);
M
Miklos Szeredi 已提交
295
	}
296 297 298 299
	spin_unlock(&fc->lock);
	wake_up(&req->waitq);
	if (end)
		end(fc, req);
300
	fuse_put_request(fc, req);
M
Miklos Szeredi 已提交
301 302
}

303 304
static void wait_answer_interruptible(struct fuse_conn *fc,
				      struct fuse_req *req)
305 306
__releases(&fc->lock)
__acquires(&fc->lock)
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
{
	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);
}

323
static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
324 325
__releases(&fc->lock)
__acquires(&fc->lock)
M
Miklos Szeredi 已提交
326
{
327 328 329
	if (!fc->no_interrupt) {
		/* Any signal may interrupt this */
		wait_answer_interruptible(fc, req);
M
Miklos Szeredi 已提交
330

331 332 333 334 335 336 337 338 339 340
		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);
	}

M
Miklos Szeredi 已提交
341
	if (!req->force) {
342 343 344
		sigset_t oldset;

		/* Only fatal signals may interrupt this */
345
		block_sigs(&oldset);
346
		wait_answer_interruptible(fc, req);
347
		restore_sigs(&oldset);
M
Miklos Szeredi 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360

		if (req->aborted)
			goto aborted;
		if (req->state == FUSE_REQ_FINISHED)
			return;

		/* Request is not yet in userspace, bail out */
		if (req->state == FUSE_REQ_PENDING) {
			list_del(&req->list);
			__fuse_put_request(req);
			req->out.h.error = -EINTR;
			return;
		}
361
	}
M
Miklos Szeredi 已提交
362

M
Miklos Szeredi 已提交
363 364 365 366 367 368 369
	/*
	 * Either request is already in userspace, or it was forced.
	 * Wait it out.
	 */
	spin_unlock(&fc->lock);
	wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
	spin_lock(&fc->lock);
370

M
Miklos Szeredi 已提交
371 372
	if (!req->aborted)
		return;
373 374

 aborted:
M
Miklos Szeredi 已提交
375
	BUG_ON(req->state != FUSE_REQ_FINISHED);
M
Miklos Szeredi 已提交
376 377 378 379 380 381
	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 */
382
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
383
		wait_event(req->waitq, !req->locked);
384
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
385 386 387
	}
}

388
void fuse_request_send(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
389 390
{
	req->isreply = 1;
391
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
392
	if (!fc->connected)
M
Miklos Szeredi 已提交
393 394 395 396 397 398 399 400 401
		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);

402
		request_wait_answer(fc, req);
M
Miklos Szeredi 已提交
403
	}
404
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
405
}
406
EXPORT_SYMBOL_GPL(fuse_request_send);
M
Miklos Szeredi 已提交
407

408 409
static void fuse_request_send_nowait_locked(struct fuse_conn *fc,
					    struct fuse_req *req)
410 411 412
{
	req->background = 1;
	fc->num_background++;
413
	if (fc->num_background == fc->max_background)
414
		fc->blocked = 1;
415
	if (fc->num_background == fc->congestion_threshold &&
416
	    fc->bdi_initialized) {
417 418
		set_bdi_congested(&fc->bdi, BLK_RW_SYNC);
		set_bdi_congested(&fc->bdi, BLK_RW_ASYNC);
419 420 421 422 423
	}
	list_add_tail(&req->list, &fc->bg_queue);
	flush_bg_queue(fc);
}

424
static void fuse_request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
425
{
426
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
427
	if (fc->connected) {
428
		fuse_request_send_nowait_locked(fc, req);
429
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
430 431 432 433 434 435
	} else {
		req->out.h.error = -ENOTCONN;
		request_end(fc, req);
	}
}

436
void fuse_request_send_noreply(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
437 438
{
	req->isreply = 0;
439
	fuse_request_send_nowait(fc, req);
M
Miklos Szeredi 已提交
440 441
}

442
void fuse_request_send_background(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
443 444
{
	req->isreply = 1;
445
	fuse_request_send_nowait(fc, req);
M
Miklos Szeredi 已提交
446
}
447
EXPORT_SYMBOL_GPL(fuse_request_send_background);
M
Miklos Szeredi 已提交
448

M
Miklos Szeredi 已提交
449 450 451 452 453
/*
 * Called under fc->lock
 *
 * fc->connected must have been checked previously
 */
454 455
void fuse_request_send_background_locked(struct fuse_conn *fc,
					 struct fuse_req *req)
M
Miklos Szeredi 已提交
456 457
{
	req->isreply = 1;
458
	fuse_request_send_nowait_locked(fc, req);
M
Miklos Szeredi 已提交
459 460
}

M
Miklos Szeredi 已提交
461 462 463
/*
 * 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
464
 * aborted bail out.
M
Miklos Szeredi 已提交
465
 */
466
static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
467 468 469
{
	int err = 0;
	if (req) {
470
		spin_lock(&fc->lock);
471
		if (req->aborted)
M
Miklos Szeredi 已提交
472 473 474
			err = -ENOENT;
		else
			req->locked = 1;
475
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
476 477 478 479 480
	}
	return err;
}

/*
481
 * Unlock request.  If it was aborted during being locked, the
M
Miklos Szeredi 已提交
482 483 484
 * requester thread is currently waiting for it to be unlocked, so
 * wake it up.
 */
485
static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
M
Miklos Szeredi 已提交
486 487
{
	if (req) {
488
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
489
		req->locked = 0;
490
		if (req->aborted)
M
Miklos Szeredi 已提交
491
			wake_up(&req->waitq);
492
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
493 494 495 496
	}
}

struct fuse_copy_state {
497
	struct fuse_conn *fc;
M
Miklos Szeredi 已提交
498 499 500 501 502 503 504 505 506 507 508 509
	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;
};

510 511 512
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 已提交
513 514
{
	memset(cs, 0, sizeof(*cs));
515
	cs->fc = fc;
M
Miklos Szeredi 已提交
516 517 518 519 520 521 522
	cs->write = write;
	cs->req = req;
	cs->iov = iov;
	cs->nr_segs = nr_segs;
}

/* Unmap and put previous page of userspace buffer */
523
static void fuse_copy_finish(struct fuse_copy_state *cs)
M
Miklos Szeredi 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
{
	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;

545
	unlock_request(cs->fc, cs->req);
M
Miklos Szeredi 已提交
546 547 548 549 550
	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;
M
Miklos Szeredi 已提交
551 552
		cs->iov++;
		cs->nr_segs--;
M
Miklos Szeredi 已提交
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
	}
	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;

568
	return lock_request(cs->fc, cs->req);
M
Miklos Szeredi 已提交
569 570 571
}

/* Do as much copy to/from userspace buffer as we can */
572
static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
M
Miklos Szeredi 已提交
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
{
	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
 */
592 593
static int fuse_copy_page(struct fuse_copy_state *cs, struct page *page,
			  unsigned offset, unsigned count, int zeroing)
M
Miklos Szeredi 已提交
594 595 596 597 598 599 600
{
	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) {
M
Miklos Szeredi 已提交
601 602 603 604 605
		if (!cs->len) {
			int err = fuse_copy_fill(cs);
			if (err)
				return err;
		}
M
Miklos Szeredi 已提交
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
		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) {
M
Miklos Szeredi 已提交
645 646 647 648 649
		if (!cs->len) {
			int err = fuse_copy_fill(cs);
			if (err)
				return err;
		}
M
Miklos Szeredi 已提交
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		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;
}

673 674 675 676 677
static int request_pending(struct fuse_conn *fc)
{
	return !list_empty(&fc->pending) || !list_empty(&fc->interrupts);
}

M
Miklos Szeredi 已提交
678 679
/* Wait until a request is available on the pending list */
static void request_wait(struct fuse_conn *fc)
680 681
__releases(&fc->lock)
__acquires(&fc->lock)
M
Miklos Szeredi 已提交
682 683 684 685
{
	DECLARE_WAITQUEUE(wait, current);

	add_wait_queue_exclusive(&fc->waitq, &wait);
686
	while (fc->connected && !request_pending(fc)) {
M
Miklos Szeredi 已提交
687 688 689 690
		set_current_state(TASK_INTERRUPTIBLE);
		if (signal_pending(current))
			break;

691
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
692
		schedule();
693
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
694 695 696 697 698
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(&fc->waitq, &wait);
}

699 700 701 702 703 704 705 706 707 708
/*
 * 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)
709
__releases(&fc->lock)
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
{
	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 已提交
739 740 741 742
/*
 * 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
743 744
 * 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 已提交
745 746 747
 * request_end().  Otherwise add it to the processing list, and set
 * the 'sent' flag.
 */
748 749
static ssize_t fuse_dev_read(struct kiocb *iocb, const struct iovec *iov,
			      unsigned long nr_segs, loff_t pos)
M
Miklos Szeredi 已提交
750 751 752 753 754 755
{
	int err;
	struct fuse_req *req;
	struct fuse_in *in;
	struct fuse_copy_state cs;
	unsigned reqsize;
756
	struct file *file = iocb->ki_filp;
M
Miklos Szeredi 已提交
757 758 759
	struct fuse_conn *fc = fuse_get_conn(file);
	if (!fc)
		return -EPERM;
M
Miklos Szeredi 已提交
760

761
 restart:
762
	spin_lock(&fc->lock);
763 764
	err = -EAGAIN;
	if ((file->f_flags & O_NONBLOCK) && fc->connected &&
765
	    !request_pending(fc))
766 767
		goto err_unlock;

M
Miklos Szeredi 已提交
768 769
	request_wait(fc);
	err = -ENODEV;
770
	if (!fc->connected)
M
Miklos Szeredi 已提交
771 772
		goto err_unlock;
	err = -ERESTARTSYS;
773
	if (!request_pending(fc))
M
Miklos Szeredi 已提交
774 775
		goto err_unlock;

776 777 778 779 780 781
	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 已提交
782
	req = list_entry(fc->pending.next, struct fuse_req, list);
783
	req->state = FUSE_REQ_READING;
784
	list_move(&req->list, &fc->io);
M
Miklos Szeredi 已提交
785 786

	in = &req->in;
787 788 789 790 791 792 793 794 795
	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 已提交
796
	}
797 798
	spin_unlock(&fc->lock);
	fuse_copy_init(&cs, fc, 1, req, iov, nr_segs);
799 800 801 802
	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 已提交
803
	fuse_copy_finish(&cs);
804
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
805
	req->locked = 0;
806 807 808 809
	if (req->aborted) {
		request_end(fc, req);
		return -ENODEV;
	}
M
Miklos Szeredi 已提交
810
	if (err) {
811
		req->out.h.error = -EIO;
M
Miklos Szeredi 已提交
812 813 814 815 816 817
		request_end(fc, req);
		return err;
	}
	if (!req->isreply)
		request_end(fc, req);
	else {
818
		req->state = FUSE_REQ_SENT;
819
		list_move_tail(&req->list, &fc->processing);
820 821
		if (req->interrupted)
			queue_interrupt(fc, req);
822
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
823 824 825 826
	}
	return reqsize;

 err_unlock:
827
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
828 829 830
	return err;
}

T
Tejun Heo 已提交
831 832 833 834
static int fuse_notify_poll(struct fuse_conn *fc, unsigned int size,
			    struct fuse_copy_state *cs)
{
	struct fuse_notify_poll_wakeup_out outarg;
M
Miklos Szeredi 已提交
835
	int err = -EINVAL;
T
Tejun Heo 已提交
836 837

	if (size != sizeof(outarg))
M
Miklos Szeredi 已提交
838
		goto err;
T
Tejun Heo 已提交
839 840 841

	err = fuse_copy_one(cs, &outarg, sizeof(outarg));
	if (err)
M
Miklos Szeredi 已提交
842
		goto err;
T
Tejun Heo 已提交
843

M
Miklos Szeredi 已提交
844
	fuse_copy_finish(cs);
T
Tejun Heo 已提交
845
	return fuse_notify_poll_wakeup(fc, &outarg);
M
Miklos Szeredi 已提交
846 847 848 849

err:
	fuse_copy_finish(cs);
	return err;
T
Tejun Heo 已提交
850 851
}

J
John Muir 已提交
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
static int fuse_notify_inval_inode(struct fuse_conn *fc, unsigned int size,
				   struct fuse_copy_state *cs)
{
	struct fuse_notify_inval_inode_out outarg;
	int err = -EINVAL;

	if (size != sizeof(outarg))
		goto err;

	err = fuse_copy_one(cs, &outarg, sizeof(outarg));
	if (err)
		goto err;
	fuse_copy_finish(cs);

	down_read(&fc->killsb);
	err = -ENOENT;
868 869 870 871
	if (fc->sb) {
		err = fuse_reverse_inval_inode(fc->sb, outarg.ino,
					       outarg.off, outarg.len);
	}
J
John Muir 已提交
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 907 908 909
	up_read(&fc->killsb);
	return err;

err:
	fuse_copy_finish(cs);
	return err;
}

static int fuse_notify_inval_entry(struct fuse_conn *fc, unsigned int size,
				   struct fuse_copy_state *cs)
{
	struct fuse_notify_inval_entry_out outarg;
	int err = -EINVAL;
	char buf[FUSE_NAME_MAX+1];
	struct qstr name;

	if (size < sizeof(outarg))
		goto err;

	err = fuse_copy_one(cs, &outarg, sizeof(outarg));
	if (err)
		goto err;

	err = -ENAMETOOLONG;
	if (outarg.namelen > FUSE_NAME_MAX)
		goto err;

	name.name = buf;
	name.len = outarg.namelen;
	err = fuse_copy_one(cs, buf, outarg.namelen + 1);
	if (err)
		goto err;
	fuse_copy_finish(cs);
	buf[outarg.namelen] = 0;
	name.hash = full_name_hash(name.name, name.len);

	down_read(&fc->killsb);
	err = -ENOENT;
910 911
	if (fc->sb)
		err = fuse_reverse_inval_entry(fc->sb, outarg.parent, &name);
J
John Muir 已提交
912 913 914 915 916 917 918 919
	up_read(&fc->killsb);
	return err;

err:
	fuse_copy_finish(cs);
	return err;
}

920 921 922 923
static int fuse_notify(struct fuse_conn *fc, enum fuse_notify_code code,
		       unsigned int size, struct fuse_copy_state *cs)
{
	switch (code) {
T
Tejun Heo 已提交
924 925 926
	case FUSE_NOTIFY_POLL:
		return fuse_notify_poll(fc, size, cs);

J
John Muir 已提交
927 928 929 930 931 932
	case FUSE_NOTIFY_INVAL_INODE:
		return fuse_notify_inval_inode(fc, size, cs);

	case FUSE_NOTIFY_INVAL_ENTRY:
		return fuse_notify_inval_entry(fc, size, cs);

933
	default:
M
Miklos Szeredi 已提交
934
		fuse_copy_finish(cs);
935 936 937 938
		return -EINVAL;
	}
}

M
Miklos Szeredi 已提交
939 940 941 942 943 944 945 946
/* 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);
947
		if (req->in.h.unique == unique || req->intr_unique == unique)
M
Miklos Szeredi 已提交
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
			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()
 */
983 984
static ssize_t fuse_dev_write(struct kiocb *iocb, const struct iovec *iov,
			       unsigned long nr_segs, loff_t pos)
M
Miklos Szeredi 已提交
985 986
{
	int err;
987
	size_t nbytes = iov_length(iov, nr_segs);
M
Miklos Szeredi 已提交
988 989 990
	struct fuse_req *req;
	struct fuse_out_header oh;
	struct fuse_copy_state cs;
991
	struct fuse_conn *fc = fuse_get_conn(iocb->ki_filp);
M
Miklos Szeredi 已提交
992
	if (!fc)
993
		return -EPERM;
M
Miklos Szeredi 已提交
994

995
	fuse_copy_init(&cs, fc, 0, NULL, iov, nr_segs);
M
Miklos Szeredi 已提交
996 997 998 999 1000 1001
	if (nbytes < sizeof(struct fuse_out_header))
		return -EINVAL;

	err = fuse_copy_one(&cs, &oh, sizeof(oh));
	if (err)
		goto err_finish;
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015

	err = -EINVAL;
	if (oh.len != nbytes)
		goto err_finish;

	/*
	 * Zero oh.unique indicates unsolicited notification message
	 * and error contains notification code.
	 */
	if (!oh.unique) {
		err = fuse_notify(fc, oh.error, nbytes - sizeof(oh), &cs);
		return err ? err : nbytes;
	}

M
Miklos Szeredi 已提交
1016
	err = -EINVAL;
1017
	if (oh.error <= -1000 || oh.error > 0)
M
Miklos Szeredi 已提交
1018 1019
		goto err_finish;

1020
	spin_lock(&fc->lock);
1021 1022 1023 1024
	err = -ENOENT;
	if (!fc->connected)
		goto err_unlock;

M
Miklos Szeredi 已提交
1025 1026 1027 1028
	req = request_find(fc, oh.unique);
	if (!req)
		goto err_unlock;

1029
	if (req->aborted) {
1030
		spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
1031
		fuse_copy_finish(&cs);
1032
		spin_lock(&fc->lock);
1033
		request_end(fc, req);
M
Miklos Szeredi 已提交
1034 1035
		return -ENOENT;
	}
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
	/* 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;
1053
	list_move(&req->list, &fc->io);
M
Miklos Szeredi 已提交
1054 1055 1056
	req->out.h = oh;
	req->locked = 1;
	cs.req = req;
1057
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
1058 1059 1060 1061

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

1062
	spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
1063 1064
	req->locked = 0;
	if (!err) {
1065
		if (req->aborted)
M
Miklos Szeredi 已提交
1066
			err = -ENOENT;
1067
	} else if (!req->aborted)
M
Miklos Szeredi 已提交
1068 1069 1070 1071 1072 1073
		req->out.h.error = -EIO;
	request_end(fc, req);

	return err ? err : nbytes;

 err_unlock:
1074
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
1075 1076 1077 1078 1079 1080 1081 1082
 err_finish:
	fuse_copy_finish(&cs);
	return err;
}

static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
{
	unsigned mask = POLLOUT | POLLWRNORM;
1083
	struct fuse_conn *fc = fuse_get_conn(file);
M
Miklos Szeredi 已提交
1084
	if (!fc)
1085
		return POLLERR;
M
Miklos Szeredi 已提交
1086 1087 1088

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

1089
	spin_lock(&fc->lock);
1090 1091
	if (!fc->connected)
		mask = POLLERR;
1092
	else if (request_pending(fc))
1093
		mask |= POLLIN | POLLRDNORM;
1094
	spin_unlock(&fc->lock);
M
Miklos Szeredi 已提交
1095 1096 1097 1098

	return mask;
}

1099 1100 1101
/*
 * Abort all requests on the given list (pending or processing)
 *
1102
 * This function releases and reacquires fc->lock
1103
 */
M
Miklos Szeredi 已提交
1104
static void end_requests(struct fuse_conn *fc, struct list_head *head)
1105 1106
__releases(&fc->lock)
__acquires(&fc->lock)
M
Miklos Szeredi 已提交
1107 1108 1109 1110 1111 1112
{
	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);
1113
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
1114 1115 1116
	}
}

1117 1118 1119
/*
 * Abort requests under I/O
 *
1120
 * The requests are set to aborted and finished, and the request
1121 1122
 * waiter is woken up.  This will make request_wait_answer() wait
 * until the request is unlocked and then return.
1123 1124 1125 1126
 *
 * 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).
1127 1128
 */
static void end_io_requests(struct fuse_conn *fc)
1129 1130
__releases(&fc->lock)
__acquires(&fc->lock)
1131 1132
{
	while (!list_empty(&fc->io)) {
1133 1134 1135 1136
		struct fuse_req *req =
			list_entry(fc->io.next, struct fuse_req, list);
		void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;

1137
		req->aborted = 1;
1138 1139 1140 1141
		req->out.h.error = -ECONNABORTED;
		req->state = FUSE_REQ_FINISHED;
		list_del_init(&req->list);
		wake_up(&req->waitq);
1142 1143 1144
		if (end) {
			req->end = NULL;
			__fuse_get_request(req);
1145
			spin_unlock(&fc->lock);
1146 1147
			wait_event(req->waitq, !req->locked);
			end(fc, req);
1148
			fuse_put_request(fc, req);
1149
			spin_lock(&fc->lock);
1150
		}
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
	}
}

/*
 * 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
1170 1171
 * prevented by the req->aborted flag being true for these requests.
 * For this reason requests on the io list must be aborted first.
1172 1173 1174
 */
void fuse_abort_conn(struct fuse_conn *fc)
{
1175
	spin_lock(&fc->lock);
1176 1177
	if (fc->connected) {
		fc->connected = 0;
1178
		fc->blocked = 0;
1179 1180 1181 1182
		end_io_requests(fc);
		end_requests(fc, &fc->pending);
		end_requests(fc, &fc->processing);
		wake_up_all(&fc->waitq);
1183
		wake_up_all(&fc->blocked_waitq);
1184
		kill_fasync(&fc->fasync, SIGIO, POLL_IN);
1185
	}
1186
	spin_unlock(&fc->lock);
1187
}
1188
EXPORT_SYMBOL_GPL(fuse_abort_conn);
1189

1190
int fuse_dev_release(struct inode *inode, struct file *file)
M
Miklos Szeredi 已提交
1191
{
M
Miklos Szeredi 已提交
1192
	struct fuse_conn *fc = fuse_get_conn(file);
M
Miklos Szeredi 已提交
1193
	if (fc) {
1194
		spin_lock(&fc->lock);
M
Miklos Szeredi 已提交
1195
		fc->connected = 0;
M
Miklos Szeredi 已提交
1196 1197
		end_requests(fc, &fc->pending);
		end_requests(fc, &fc->processing);
1198
		spin_unlock(&fc->lock);
1199
		fuse_conn_put(fc);
1200
	}
1201

M
Miklos Szeredi 已提交
1202 1203
	return 0;
}
1204
EXPORT_SYMBOL_GPL(fuse_dev_release);
M
Miklos Szeredi 已提交
1205

1206 1207 1208 1209
static int fuse_dev_fasync(int fd, struct file *file, int on)
{
	struct fuse_conn *fc = fuse_get_conn(file);
	if (!fc)
1210
		return -EPERM;
1211 1212 1213 1214 1215

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

1216
const struct file_operations fuse_dev_operations = {
M
Miklos Szeredi 已提交
1217 1218
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
1219 1220 1221 1222
	.read		= do_sync_read,
	.aio_read	= fuse_dev_read,
	.write		= do_sync_write,
	.aio_write	= fuse_dev_write,
M
Miklos Szeredi 已提交
1223 1224
	.poll		= fuse_dev_poll,
	.release	= fuse_dev_release,
1225
	.fasync		= fuse_dev_fasync,
M
Miklos Szeredi 已提交
1226
};
1227
EXPORT_SYMBOL_GPL(fuse_dev_operations);
M
Miklos Szeredi 已提交
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239

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),
1240
					    0, 0, NULL);
M
Miklos Szeredi 已提交
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
	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);
}