upcall.c 22.8 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Mostly platform independent upcall operations to Venus:
 *  -- upcalls
 *  -- upcall routines
 *
 * Linux 2.0 version
 * Copyright (C) 1996 Peter J. Braam <braam@maths.ox.ac.uk>, 
 * Michael Callahan <callahan@maths.ox.ac.uk> 
 * 
 * Redone for Linux 2.1
 * Copyright (C) 1997 Carnegie Mellon University
 *
 * Carnegie Mellon University encourages users of this code to contribute
 * improvements to the Coda project. Contact Peter Braam <coda@cs.cmu.edu>.
 */

#include <linux/signal.h>
19
#include <linux/sched/signal.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22 23 24 25 26 27 28
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/time.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/string.h>
29
#include <linux/slab.h>
Yoshihisa Abe's avatar
Yoshihisa Abe committed
30
#include <linux/mutex.h>
31
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35 36
#include <linux/vmalloc.h>
#include <linux/vfs.h>

#include <linux/coda.h>
#include <linux/coda_psdev.h>
37 38
#include "coda_linux.h"
#include "coda_cache.h"
39 40

#include "coda_int.h"
Linus Torvalds's avatar
Linus Torvalds committed
41

42
static int coda_upcall(struct venus_comm *vc, int inSize, int *outSize,
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46 47 48 49 50 51 52 53
		       union inputArgs *buffer);

static void *alloc_upcall(int opcode, int size)
{
	union inputArgs *inp;

	CODA_ALLOC(inp, union inputArgs *, size);
        if (!inp)
		return ERR_PTR(-ENOMEM);

        inp->ih.opcode = opcode;
54 55
	inp->ih.pid = task_pid_nr_ns(current, &init_pid_ns);
	inp->ih.pgid = task_pgrp_nr_ns(current, &init_pid_ns);
56
	inp->ih.uid = from_kuid(&init_user_ns, current_fsuid());
Adrian Bunk's avatar
Adrian Bunk committed
57

Linus Torvalds's avatar
Linus Torvalds committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
	return (void*)inp;
}

#define UPARG(op)\
do {\
	inp = (union inputArgs *)alloc_upcall(op, insize); \
        if (IS_ERR(inp)) { return PTR_ERR(inp); }\
        outp = (union outputArgs *)(inp); \
        outsize = insize; \
} while (0)

#define INSIZE(tag) sizeof(struct coda_ ## tag ## _in)
#define OUTSIZE(tag) sizeof(struct coda_ ## tag ## _out)
#define SIZE(tag)  max_t(unsigned int, INSIZE(tag), OUTSIZE(tag))


/* the upcalls */
int venus_rootfid(struct super_block *sb, struct CodaFid *fidp)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;

        insize = SIZE(root);
        UPARG(CODA_ROOT);

84
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
85
	if (!error)
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
		*fidp = outp->coda_root.VFid;

	CODA_FREE(inp, insize);
	return error;
}

int venus_getattr(struct super_block *sb, struct CodaFid *fid, 
		     struct coda_vattr *attr) 
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;

        insize = SIZE(getattr); 
	UPARG(CODA_GETATTR);
        inp->coda_getattr.VFid = *fid;

103
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
104 105
	if (!error)
		*attr = outp->coda_getattr.attr;
Linus Torvalds's avatar
Linus Torvalds committed
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

	CODA_FREE(inp, insize);
        return error;
}

int venus_setattr(struct super_block *sb, struct CodaFid *fid, 
		  struct coda_vattr *vattr)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
	
	insize = SIZE(setattr);
	UPARG(CODA_SETATTR);

        inp->coda_setattr.VFid = *fid;
	inp->coda_setattr.attr = *vattr;

124
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
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

        CODA_FREE(inp, insize);
        return error;
}

int venus_lookup(struct super_block *sb, struct CodaFid *fid, 
		    const char *name, int length, int * type, 
		    struct CodaFid *resfid)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
	int offset;

	offset = INSIZE(lookup);
        insize = max_t(unsigned int, offset + length +1, OUTSIZE(lookup));
	UPARG(CODA_LOOKUP);

        inp->coda_lookup.VFid = *fid;
	inp->coda_lookup.name = offset;
	inp->coda_lookup.flags = CLU_CASE_SENSITIVE;
        /* send Venus a null terminated string */
        memcpy((char *)(inp) + offset, name, length);
        *((char *)inp + offset + length) = '\0';

150
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
151 152 153 154
	if (!error) {
		*resfid = outp->coda_lookup.VFid;
		*type = outp->coda_lookup.vtype;
	}
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160

	CODA_FREE(inp, insize);
	return error;
}

int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
161
		kuid_t uid)
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164 165 166 167 168 169
{
	union inputArgs *inp;
	union outputArgs *outp;
	int insize, outsize, error;
	
	insize = SIZE(release);
	UPARG(CODA_CLOSE);
	
170
	inp->ih.uid = from_kuid(&init_user_ns, uid);
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173
        inp->coda_close.VFid = *fid;
        inp->coda_close.flags = flags;

174
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189

	CODA_FREE(inp, insize);
        return error;
}

int venus_open(struct super_block *sb, struct CodaFid *fid,
		  int flags, struct file **fh)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
       
	insize = SIZE(open_by_fd);
	UPARG(CODA_OPEN_BY_FD);

190 191
	inp->coda_open_by_fd.VFid = *fid;
	inp->coda_open_by_fd.flags = flags;
Linus Torvalds's avatar
Linus Torvalds committed
192

193
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
194 195
	if (!error)
		*fh = outp->coda_open_by_fd.fh;
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

	CODA_FREE(inp, insize);
	return error;
}	

int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid, 
		   const char *name, int length, 
		   struct CodaFid *newfid, struct coda_vattr *attrs)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int offset;

	offset = INSIZE(mkdir);
	insize = max_t(unsigned int, offset + length + 1, OUTSIZE(mkdir));
	UPARG(CODA_MKDIR);

        inp->coda_mkdir.VFid = *dirfid;
        inp->coda_mkdir.attr = *attrs;
	inp->coda_mkdir.name = offset;
        /* Venus must get null terminated string */
        memcpy((char *)(inp) + offset, name, length);
        *((char *)inp + offset + length) = '\0';

221
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
222 223 224 225
	if (!error) {
		*attrs = outp->coda_mkdir.attr;
		*newfid = outp->coda_mkdir.VFid;
	}
Linus Torvalds's avatar
Linus Torvalds committed
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 253 254 255 256 257 258 259 260 261 262

	CODA_FREE(inp, insize);
	return error;        
}


int venus_rename(struct super_block *sb, struct CodaFid *old_fid, 
		 struct CodaFid *new_fid, size_t old_length, 
		 size_t new_length, const char *old_name, 
		 const char *new_name)
{
	union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error; 
	int offset, s;
	
	offset = INSIZE(rename);
	insize = max_t(unsigned int, offset + new_length + old_length + 8,
		     OUTSIZE(rename)); 
 	UPARG(CODA_RENAME);

        inp->coda_rename.sourceFid = *old_fid;
        inp->coda_rename.destFid =  *new_fid;
        inp->coda_rename.srcname = offset;

        /* Venus must receive an null terminated string */
        s = ( old_length & ~0x3) +4; /* round up to word boundary */
        memcpy((char *)(inp) + offset, old_name, old_length);
        *((char *)inp + offset + old_length) = '\0';

        /* another null terminated string for Venus */
        offset += s;
        inp->coda_rename.destname = offset;
        s = ( new_length & ~0x3) +4; /* round up to word boundary */
        memcpy((char *)(inp) + offset, new_name, new_length);
        *((char *)inp + offset + new_length) = '\0';

263
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291

	CODA_FREE(inp, insize);
	return error;
}

int venus_create(struct super_block *sb, struct CodaFid *dirfid, 
		 const char *name, int length, int excl, int mode,
		 struct CodaFid *newfid, struct coda_vattr *attrs) 
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int offset;

        offset = INSIZE(create);
	insize = max_t(unsigned int, offset + length + 1, OUTSIZE(create));
	UPARG(CODA_CREATE);

        inp->coda_create.VFid = *dirfid;
        inp->coda_create.attr.va_mode = mode;
	inp->coda_create.excl = excl;
        inp->coda_create.mode = mode;
        inp->coda_create.name = offset;

        /* Venus must get null terminated string */
        memcpy((char *)(inp) + offset, name, length);
        *((char *)inp + offset + length) = '\0';

292
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
293 294 295 296
	if (!error) {
		*attrs = outp->coda_create.attr;
		*newfid = outp->coda_create.VFid;
	}
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317

	CODA_FREE(inp, insize);
	return error;        
}

int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid, 
		    const char *name, int length)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int offset;

        offset = INSIZE(rmdir);
	insize = max_t(unsigned int, offset + length + 1, OUTSIZE(rmdir));
	UPARG(CODA_RMDIR);

        inp->coda_rmdir.VFid = *dirfid;
        inp->coda_rmdir.name = offset;
        memcpy((char *)(inp) + offset, name, length);
	*((char *)inp + offset + length) = '\0';
318 319

	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

	CODA_FREE(inp, insize);
	return error;
}

int venus_remove(struct super_block *sb, struct CodaFid *dirfid, 
		    const char *name, int length)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int error=0, insize, outsize, offset;

        offset = INSIZE(remove);
	insize = max_t(unsigned int, offset + length + 1, OUTSIZE(remove));
	UPARG(CODA_REMOVE);

        inp->coda_remove.VFid = *dirfid;
        inp->coda_remove.name = offset;
        memcpy((char *)(inp) + offset, name, length);
	*((char *)inp + offset + length) = '\0';
340 341

	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356

	CODA_FREE(inp, insize);
	return error;
}

int venus_readlink(struct super_block *sb, struct CodaFid *fid, 
		      char *buffer, int *length)
{ 
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int retlen;
        char *result;
        
	insize = max_t(unsigned int,
357
		     INSIZE(readlink), OUTSIZE(readlink)+ *length);
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360
	UPARG(CODA_READLINK);

        inp->coda_readlink.VFid = *fid;
361

362
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
363 364
	if (!error) {
		retlen = outp->coda_readlink.count;
365 366
		if (retlen >= *length)
			retlen = *length - 1;
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369 370 371
		*length = retlen;
		result =  (char *)outp + (long)outp->coda_readlink.data;
		memcpy(buffer, result, retlen);
		*(buffer + retlen) = '\0';
	}
372

Linus Torvalds's avatar
Linus Torvalds committed
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
        CODA_FREE(inp, insize);
        return error;
}



int venus_link(struct super_block *sb, struct CodaFid *fid, 
		  struct CodaFid *dirfid, const char *name, int len )
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int offset;

	offset = INSIZE(link);
	insize = max_t(unsigned int, offset  + len + 1, OUTSIZE(link));
        UPARG(CODA_LINK);

        inp->coda_link.sourceFid = *fid;
        inp->coda_link.destFid = *dirfid;
        inp->coda_link.tname = offset;

        /* make sure strings are null terminated */
        memcpy((char *)(inp) + offset, name, len);
        *((char *)inp + offset + len) = '\0';
398 399

	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

	CODA_FREE(inp, insize);
        return error;
}

int venus_symlink(struct super_block *sb, struct CodaFid *fid,
		     const char *name, int len,
		     const char *symname, int symlen)
{
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        int offset, s;

        offset = INSIZE(symlink);
	insize = max_t(unsigned int, offset + len + symlen + 8, OUTSIZE(symlink));
	UPARG(CODA_SYMLINK);
        
        /*        inp->coda_symlink.attr = *tva; XXXXXX */ 
        inp->coda_symlink.VFid = *fid;

	/* Round up to word boundary and null terminate */
        inp->coda_symlink.srcname = offset;
        s = ( symlen  & ~0x3 ) + 4; 
        memcpy((char *)(inp) + offset, symname, symlen);
        *((char *)inp + offset + symlen) = '\0';
        
	/* Round up to word boundary and null terminate */
        offset += s;
        inp->coda_symlink.tname = offset;
        s = (len & ~0x3) + 4;
        memcpy((char *)(inp) + offset, name, len);
        *((char *)inp + offset + len) = '\0';

434
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448

	CODA_FREE(inp, insize);
        return error;
}

int venus_fsync(struct super_block *sb, struct CodaFid *fid)
{
        union inputArgs *inp;
        union outputArgs *outp; 
	int insize, outsize, error;
	
	insize=SIZE(fsync);
	UPARG(CODA_FSYNC);

449
	inp->coda_fsync.VFid = *fid;
450
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467

	CODA_FREE(inp, insize);
	return error;
}

int venus_access(struct super_block *sb, struct CodaFid *fid, int mask)
{
        union inputArgs *inp;
        union outputArgs *outp; 
	int insize, outsize, error;

	insize = SIZE(access);
	UPARG(CODA_ACCESS);

        inp->coda_access.VFid = *fid;
        inp->coda_access.flags = mask;

468
	error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510

	CODA_FREE(inp, insize);
	return error;
}


int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
		 unsigned int cmd, struct PioctlData *data)
{
        union inputArgs *inp;
        union outputArgs *outp;  
	int insize, outsize, error;
	int iocsize;

	insize = VC_MAXMSGSIZE;
	UPARG(CODA_IOCTL);

        /* build packet for Venus */
        if (data->vi.in_size > VC_MAXDATASIZE) {
		error = -EINVAL;
		goto exit;
        }

        if (data->vi.out_size > VC_MAXDATASIZE) {
		error = -EINVAL;
		goto exit;
	}

        inp->coda_ioctl.VFid = *fid;
    
        /* the cmd field was mutated by increasing its size field to
         * reflect the path and follow args. We need to subtract that
         * out before sending the command to Venus.  */
        inp->coda_ioctl.cmd = (cmd & ~(PIOCPARM_MASK << 16));	
        iocsize = ((cmd >> 16) & PIOCPARM_MASK) - sizeof(char *) - sizeof(int);
        inp->coda_ioctl.cmd |= (iocsize & PIOCPARM_MASK) <<	16;	
    
        /* in->coda_ioctl.rwflag = flag; */
        inp->coda_ioctl.len = data->vi.in_size;
        inp->coda_ioctl.data = (char *)(INSIZE(ioctl));
     
        /* get the data out of user space */
511 512
	if (copy_from_user((char *)inp + (long)inp->coda_ioctl.data,
			   data->vi.in, data->vi.in_size)) {
Linus Torvalds's avatar
Linus Torvalds committed
513 514 515 516
		error = -EINVAL;
	        goto exit;
	}

517 518 519
	error = coda_upcall(coda_vcp(sb), SIZE(ioctl) + data->vi.in_size,
			    &outsize, inp);

Linus Torvalds's avatar
Linus Torvalds committed
520
        if (error) {
Fabian Frederick's avatar
Fabian Frederick committed
521 522
		pr_warn("%s: Venus returns: %d for %s\n",
			__func__, error, coda_f2s(fid));
Linus Torvalds's avatar
Linus Torvalds committed
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
		goto exit; 
	}

	if (outsize < (long)outp->coda_ioctl.data + outp->coda_ioctl.len) {
		error = -EINVAL;
		goto exit;
	}
        
	/* Copy out the OUT buffer. */
        if (outp->coda_ioctl.len > data->vi.out_size) {
		error = -EINVAL;
		goto exit;
        }

	/* Copy out the OUT buffer. */
	if (copy_to_user(data->vi.out,
			 (char *)outp + (long)outp->coda_ioctl.data,
			 outp->coda_ioctl.len)) {
		error = -EFAULT;
		goto exit;
	}

 exit:
	CODA_FREE(inp, insize);
	return error;
}

550
int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554 555 556 557 558
{ 
        union inputArgs *inp;
        union outputArgs *outp;
        int insize, outsize, error;
        
	insize = max_t(unsigned int, INSIZE(statfs), OUTSIZE(statfs));
	UPARG(CODA_STATFS);

559
	error = coda_upcall(coda_vcp(dentry->d_sb), insize, &outsize, inp);
560
	if (!error) {
Linus Torvalds's avatar
Linus Torvalds committed
561 562 563 564 565 566 567 568 569 570 571 572 573 574
		sfs->f_blocks = outp->coda_statfs.stat.f_blocks;
		sfs->f_bfree  = outp->coda_statfs.stat.f_bfree;
		sfs->f_bavail = outp->coda_statfs.stat.f_bavail;
		sfs->f_files  = outp->coda_statfs.stat.f_files;
		sfs->f_ffree  = outp->coda_statfs.stat.f_ffree;
	}

        CODA_FREE(inp, insize);
        return error;
}

/*
 * coda_upcall and coda_downcall routines.
 */
Al Viro's avatar
Al Viro committed
575
static void coda_block_signals(sigset_t *old)
576 577 578 579 580 581 582 583 584 585 586 587 588
{
	spin_lock_irq(&current->sighand->siglock);
	*old = current->blocked;

	sigfillset(&current->blocked);
	sigdelset(&current->blocked, SIGKILL);
	sigdelset(&current->blocked, SIGSTOP);
	sigdelset(&current->blocked, SIGINT);

	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
}

Al Viro's avatar
Al Viro committed
589
static void coda_unblock_signals(sigset_t *old)
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
{
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = *old;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);
}

/* Don't allow signals to interrupt the following upcalls before venus
 * has seen them,
 * - CODA_CLOSE or CODA_RELEASE upcall  (to avoid reference count problems)
 * - CODA_STORE				(to avoid data loss)
 */
#define CODA_INTERRUPTIBLE(r) (!coda_hard && \
			       (((r)->uc_opcode != CODA_CLOSE && \
				 (r)->uc_opcode != CODA_STORE && \
				 (r)->uc_opcode != CODA_RELEASE) || \
606
				(r)->uc_flags & CODA_REQ_READ))
Linus Torvalds's avatar
Linus Torvalds committed
607

Yoshihisa Abe's avatar
Yoshihisa Abe committed
608 609
static inline void coda_waitfor_upcall(struct venus_comm *vcp,
				       struct upc_req *req)
Linus Torvalds's avatar
Linus Torvalds committed
610 611
{
	DECLARE_WAITQUEUE(wait, current);
612 613 614
	unsigned long timeout = jiffies + coda_timeout * HZ;
	sigset_t old;
	int blocked;
Linus Torvalds's avatar
Linus Torvalds committed
615

Al Viro's avatar
Al Viro committed
616
	coda_block_signals(&old);
617
	blocked = 1;
Linus Torvalds's avatar
Linus Torvalds committed
618

619
	add_wait_queue(&req->uc_sleep, &wait);
Linus Torvalds's avatar
Linus Torvalds committed
620
	for (;;) {
621
		if (CODA_INTERRUPTIBLE(req))
Linus Torvalds's avatar
Linus Torvalds committed
622 623 624 625 626
			set_current_state(TASK_INTERRUPTIBLE);
		else
			set_current_state(TASK_UNINTERRUPTIBLE);

		/* got a reply */
627
		if (req->uc_flags & (CODA_REQ_WRITE | CODA_REQ_ABORT))
Linus Torvalds's avatar
Linus Torvalds committed
628 629
			break;

630 631 632
		if (blocked && time_after(jiffies, timeout) &&
		    CODA_INTERRUPTIBLE(req))
		{
Al Viro's avatar
Al Viro committed
633
			coda_unblock_signals(&old);
634
			blocked = 0;
Linus Torvalds's avatar
Linus Torvalds committed
635
		}
636 637 638 639 640 641

		if (signal_pending(current)) {
			list_del(&req->uc_chain);
			break;
		}

Yoshihisa Abe's avatar
Yoshihisa Abe committed
642
		mutex_unlock(&vcp->vc_mutex);
643 644 645 646
		if (blocked)
			schedule_timeout(HZ);
		else
			schedule();
Yoshihisa Abe's avatar
Yoshihisa Abe committed
647
		mutex_lock(&vcp->vc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
648
	}
649
	if (blocked)
Al Viro's avatar
Al Viro committed
650
		coda_unblock_signals(&old);
Linus Torvalds's avatar
Linus Torvalds committed
651

652 653
	remove_wait_queue(&req->uc_sleep, &wait);
	set_current_state(TASK_RUNNING);
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656
}


657 658
/*
 * coda_upcall will return an error in the case of
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662 663 664 665
 * failed communication with Venus _or_ will peek at Venus
 * reply and return Venus' error.
 *
 * As venus has 2 types of errors, normal errors (positive) and internal
 * errors (negative), normal errors are negated, while internal errors
 * are all mapped to -EINTR, while showing a nice warning message. (jh)
 */
666
static int coda_upcall(struct venus_comm *vcp,
667 668
		       int inSize, int *outSize,
		       union inputArgs *buffer)
Linus Torvalds's avatar
Linus Torvalds committed
669 670
{
	union outputArgs *out;
671
	union inputArgs *sig_inputArgs;
672 673 674
	struct upc_req *req = NULL, *sig_req;
	int error;

Yoshihisa Abe's avatar
Yoshihisa Abe committed
675
	mutex_lock(&vcp->vc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
676

677
	if (!vcp->vc_inuse) {
678
		pr_notice("Venus dead, not sending upcall\n");
679 680
		error = -ENXIO;
		goto exit;
Linus Torvalds's avatar
Linus Torvalds committed
681 682 683
	}

	/* Format the request message. */
684
	req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
685 686 687 688
	if (!req) {
		error = -ENOMEM;
		goto exit;
	}
689

Linus Torvalds's avatar
Linus Torvalds committed
690 691 692 693 694
	req->uc_data = (void *)buffer;
	req->uc_flags = 0;
	req->uc_inSize = inSize;
	req->uc_outSize = *outSize ? *outSize : inSize;
	req->uc_opcode = ((union inputArgs *)buffer)->ih.opcode;
695
	req->uc_unique = ++vcp->vc_seq;
Linus Torvalds's avatar
Linus Torvalds committed
696
	init_waitqueue_head(&req->uc_sleep);
697

Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701
	/* Fill in the common input args. */
	((union inputArgs *)buffer)->ih.unique = req->uc_unique;

	/* Append msg to pending queue and poke Venus. */
702
	list_add_tail(&req->uc_chain, &vcp->vc_pending);
703

704
	wake_up_interruptible(&vcp->vc_waitq);
Linus Torvalds's avatar
Linus Torvalds committed
705 706 707 708 709 710 711 712 713 714
	/* We can be interrupted while we wait for Venus to process
	 * our request.  If the interrupt occurs before Venus has read
	 * the request, we dequeue and return. If it occurs after the
	 * read but before the reply, we dequeue, send a signal
	 * message, and return. If it occurs after the reply we ignore
	 * it. In no case do we want to restart the syscall.  If it
	 * was interrupted by a venus shutdown (psdev_close), return
	 * ENODEV.  */

	/* Go to sleep.  Wake up on signals only after the timeout. */
Yoshihisa Abe's avatar
Yoshihisa Abe committed
715
	coda_waitfor_upcall(vcp, req);
Linus Torvalds's avatar
Linus Torvalds committed
716

717
	/* Op went through, interrupt or not... */
718
	if (req->uc_flags & CODA_REQ_WRITE) {
Linus Torvalds's avatar
Linus Torvalds committed
719 720 721 722 723
		out = (union outputArgs *)req->uc_data;
		/* here we map positive Venus errors to kernel errors */
		error = -out->oh.result;
		*outSize = req->uc_outSize;
		goto exit;
724 725 726
	}

	error = -EINTR;
727
	if ((req->uc_flags & CODA_REQ_ABORT) || !signal_pending(current)) {
728
		pr_warn("Unexpected interruption.\n");
Linus Torvalds's avatar
Linus Torvalds committed
729 730 731
		goto exit;
	}

732
	/* Interrupted before venus read it. */
733
	if (!(req->uc_flags & CODA_REQ_READ))
734 735 736
		goto exit;

	/* Venus saw the upcall, make sure we can send interrupt signal */
737
	if (!vcp->vc_inuse) {
738
		pr_info("Venus dead, not sending signal.\n");
739 740 741 742
		goto exit;
	}

	error = -ENOMEM;
743
	sig_req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
744 745 746 747
	if (!sig_req) goto exit;

	CODA_ALLOC((sig_req->uc_data), char *, sizeof(struct coda_in_hdr));
	if (!sig_req->uc_data) {
748
		kfree(sig_req);
749 750 751 752 753 754 755 756
		goto exit;
	}

	error = -EINTR;
	sig_inputArgs = (union inputArgs *)sig_req->uc_data;
	sig_inputArgs->ih.opcode = CODA_SIGNAL;
	sig_inputArgs->ih.unique = req->uc_unique;

757
	sig_req->uc_flags = CODA_REQ_ASYNC;
758 759 760 761 762 763
	sig_req->uc_opcode = sig_inputArgs->ih.opcode;
	sig_req->uc_unique = sig_inputArgs->ih.unique;
	sig_req->uc_inSize = sizeof(struct coda_in_hdr);
	sig_req->uc_outSize = sizeof(struct coda_in_hdr);

	/* insert at head of queue! */
764 765
	list_add(&(sig_req->uc_chain), &vcp->vc_pending);
	wake_up_interruptible(&vcp->vc_waitq);
766 767

exit:
768
	kfree(req);
Yoshihisa Abe's avatar
Yoshihisa Abe committed
769
	mutex_unlock(&vcp->vc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774 775 776 777 778 779 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
	return error;
}

/*  
    The statements below are part of the Coda opportunistic
    programming -- taken from the Mach/BSD kernel code for Coda. 
    You don't get correct semantics by stating what needs to be
    done without guaranteeing the invariants needed for it to happen.
    When will be have time to find out what exactly is going on?  (pjb)
*/


/* 
 * There are 7 cases where cache invalidations occur.  The semantics
 *  of each is listed here:
 *
 * CODA_FLUSH     -- flush all entries from the name cache and the cnode cache.
 * CODA_PURGEUSER -- flush all entries from the name cache for a specific user
 *                  This call is a result of token expiration.
 *
 * The next arise as the result of callbacks on a file or directory.
 * CODA_ZAPFILE   -- flush the cached attributes for a file.

 * CODA_ZAPDIR    -- flush the attributes for the dir and
 *                  force a new lookup for all the children
                    of this dir.

 *
 * The next is a result of Venus detecting an inconsistent file.
 * CODA_PURGEFID  -- flush the attribute for the file
 *                  purge it and its children from the dcache
 *
 * The last  allows Venus to replace local fids with global ones
 * during reintegration.
 *
 * CODA_REPLACE -- replace one CodaFid with another throughout the name cache */

807
int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out)
Linus Torvalds's avatar
Linus Torvalds committed
808
{
Jan Harkes's avatar
Jan Harkes committed
809
	struct inode *inode = NULL;
Yoshihisa Abe's avatar
Yoshihisa Abe committed
810
	struct CodaFid *fid = NULL, *newfid;
811
	struct super_block *sb;
Jan Harkes's avatar
Jan Harkes committed
812

Linus Torvalds's avatar
Linus Torvalds committed
813
	/* Handle invalidation requests. */
Yoshihisa Abe's avatar
Yoshihisa Abe committed
814
	mutex_lock(&vcp->vc_mutex);
815 816 817
	sb = vcp->vc_sb;
	if (!sb || !sb->s_root)
		goto unlock_out;
Jan Harkes's avatar
Jan Harkes committed
818 819 820 821 822

	switch (opcode) {
	case CODA_FLUSH:
		coda_cache_clear_all(sb);
		shrink_dcache_sb(sb);
823 824
		if (d_really_is_positive(sb->s_root))
			coda_flag_inode(d_inode(sb->s_root), C_FLUSH);
Jan Harkes's avatar
Jan Harkes committed
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
		break;

	case CODA_PURGEUSER:
		coda_cache_clear_all(sb);
		break;

	case CODA_ZAPDIR:
		fid = &out->coda_zapdir.CodaFid;
		break;

	case CODA_ZAPFILE:
		fid = &out->coda_zapfile.CodaFid;
		break;

	case CODA_PURGEFID:
		fid = &out->coda_purgefid.CodaFid;
		break;

	case CODA_REPLACE:
		fid = &out->coda_replace.OldFid;
		break;
	}
Yoshihisa Abe's avatar
Yoshihisa Abe committed
847 848
	if (fid)
		inode = coda_fid_to_inode(fid, sb);
Jan Harkes's avatar
Jan Harkes committed
849

850
unlock_out:
Yoshihisa Abe's avatar
Yoshihisa Abe committed
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
	mutex_unlock(&vcp->vc_mutex);

	if (!inode)
		return 0;

	switch (opcode) {
	case CODA_ZAPDIR:
		coda_flag_inode_children(inode, C_PURGE);
		coda_flag_inode(inode, C_VATTR);
		break;

	case CODA_ZAPFILE:
		coda_flag_inode(inode, C_VATTR);
		break;

	case CODA_PURGEFID:
		coda_flag_inode_children(inode, C_PURGE);
868

Yoshihisa Abe's avatar
Yoshihisa Abe committed
869 870 871 872 873 874 875 876 877 878 879
		/* catch the dentries later if some are still busy */
		coda_flag_inode(inode, C_PURGE);
		d_prune_aliases(inode);
		break;

	case CODA_REPLACE:
		newfid = &out->coda_replace.NewFid;
		coda_replace_fid(inode, fid, newfid);
		break;
	}
	iput(inode);
Jan Harkes's avatar
Jan Harkes committed
880
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
881 882
}