fs/coda/upcall.c

   1 /*
   2  * Mostly platform independent upcall operations to Venus:
   3  *  -- upcalls
   4  *  -- upcall routines
   5  *
   6  * Linux 2.0 version
   7  * Copyright (C) 1996 Peter J. Braam <braam@maths.ox.ac.uk>,
   8  * Michael Callahan <callahan@maths.ox.ac.uk>
   9  *
  10  * Redone for Linux 2.1
  11  * Copyright (C) 1997 Carnegie Mellon University
  12  *
  13  * Carnegie Mellon University encourages users of this code to contribute
  14  * improvements to the Coda project. Contact Peter Braam <coda@cs.cmu.edu>.
  15  */
  16
  17 #include <asm/system.h>
  18 #include <linux/signal.h>
  19 #include <linux/sched.h>
  20 #include <linux/types.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/time.h>
  24 #include <linux/fs.h>
  25 #include <linux/file.h>
  26 #include <linux/stat.h>
  27 #include <linux/errno.h>
  28 #include <linux/string.h>
  29 #include <asm/uaccess.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/vfs.h>
  32
  33 #include <linux/coda.h>
  34 #include <linux/coda_linux.h>
  35 #include <linux/coda_psdev.h>
  36 #include <linux/coda_fs_i.h>
  37 #include <linux/coda_cache.h>
  38
  39 #include "coda_int.h"
  40
  41 static int coda_upcall(struct venus_comm *vc, int inSize, int *outSize,
  42                        union inputArgs *buffer);
  43
  44 static void *alloc_upcall(int opcode, int size)
  45 {
  46         union inputArgs *inp;
  47
  48         CODA_ALLOC(inp, union inputArgs *, size);
  49         if (!inp)
  50                 return ERR_PTR(-ENOMEM);
  51
  52         inp->ih.opcode = opcode;
  53         inp->ih.pid = current->pid;
  54         inp->ih.pgid = process_group(current);
  55 #ifdef CONFIG_CODA_FS_OLD_API
  56         memset(&inp->ih.cred, 0, sizeof(struct coda_cred));
  57         inp->ih.cred.cr_fsuid = current->fsuid;
  58 #else
  59         inp->ih.uid = current->fsuid;
  60 #endif
  61         return (void*)inp;
  62 }
  63
  64 #define UPARG(op)\
  65 do {\
  66         inp = (union inputArgs *)alloc_upcall(op, insize); \
  67         if (IS_ERR(inp)) { return PTR_ERR(inp); }\
  68         outp = (union outputArgs *)(inp); \
  69         outsize = insize; \
  70 } while (0)
  71
  72 #define INSIZE(tag) sizeof(struct coda_ ## tag ## _in)
  73 #define OUTSIZE(tag) sizeof(struct coda_ ## tag ## _out)
  74 #define SIZE(tag)  max_t(unsigned int, INSIZE(tag), OUTSIZE(tag))
  75
  76
  77 /* the upcalls */
  78 int venus_rootfid(struct super_block *sb, struct CodaFid *fidp)
  79 {
  80         union inputArgs *inp;
  81         union outputArgs *outp;
  82         int insize, outsize, error;
  83
  84         insize = SIZE(root);
  85         UPARG(CODA_ROOT);
  86
  87         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
  88         if (!error)
  89                 *fidp = outp->coda_root.VFid;
  90
  91         CODA_FREE(inp, insize);
  92         return error;
  93 }
  94
  95 int venus_getattr(struct super_block *sb, struct CodaFid *fid,
  96                      struct coda_vattr *attr)
  97 {
  98         union inputArgs *inp;
  99         union outputArgs *outp;
 100         int insize, outsize, error;
 101
 102         insize = SIZE(getattr);
 103         UPARG(CODA_GETATTR);
 104         inp->coda_getattr.VFid = *fid;
 105
 106         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 107         if (!error)
 108                 *attr = outp->coda_getattr.attr;
 109
 110         CODA_FREE(inp, insize);
 111         return error;
 112 }
 113
 114 int venus_setattr(struct super_block *sb, struct CodaFid *fid,
 115                   struct coda_vattr *vattr)
 116 {
 117         union inputArgs *inp;
 118         union outputArgs *outp;
 119         int insize, outsize, error;
 120
 121         insize = SIZE(setattr);
 122         UPARG(CODA_SETATTR);
 123
 124         inp->coda_setattr.VFid = *fid;
 125         inp->coda_setattr.attr = *vattr;
 126
 127         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 128
 129         CODA_FREE(inp, insize);
 130         return error;
 131 }
 132
 133 int venus_lookup(struct super_block *sb, struct CodaFid *fid,
 134                     const char *name, int length, int * type,
 135                     struct CodaFid *resfid)
 136 {
 137         union inputArgs *inp;
 138         union outputArgs *outp;
 139         int insize, outsize, error;
 140         int offset;
 141
 142         offset = INSIZE(lookup);
 143         insize = max_t(unsigned int, offset + length +1, OUTSIZE(lookup));
 144         UPARG(CODA_LOOKUP);
 145
 146         inp->coda_lookup.VFid = *fid;
 147         inp->coda_lookup.name = offset;
 148         inp->coda_lookup.flags = CLU_CASE_SENSITIVE;
 149         /* send Venus a null terminated string */
 150         memcpy((char *)(inp) + offset, name, length);
 151         *((char *)inp + offset + length) = '\0';
 152
 153         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 154         if (!error) {
 155                 *resfid = outp->coda_lookup.VFid;
 156                 *type = outp->coda_lookup.vtype;
 157         }
 158
 159         CODA_FREE(inp, insize);
 160         return error;
 161 }
 162
 163 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
 164                 vuid_t uid)
 165 {
 166         union inputArgs *inp;
 167         union outputArgs *outp;
 168         int insize, outsize, error;
 169 #ifdef CONFIG_CODA_FS_OLD_API
 170         struct coda_cred cred = { 0, };
 171         cred.cr_fsuid = uid;
 172 #endif
 173
 174         insize = SIZE(release);
 175         UPARG(CODA_CLOSE);
 176
 177 #ifdef CONFIG_CODA_FS_OLD_API
 178         memcpy(&(inp->ih.cred), &cred, sizeof(cred));
 179 #else
 180         inp->ih.uid = uid;
 181 #endif
 182
 183         inp->coda_close.VFid = *fid;
 184         inp->coda_close.flags = flags;
 185
 186         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 187
 188         CODA_FREE(inp, insize);
 189         return error;
 190 }
 191
 192 int venus_open(struct super_block *sb, struct CodaFid *fid,
 193                   int flags, struct file **fh)
 194 {
 195         union inputArgs *inp;
 196         union outputArgs *outp;
 197         int insize, outsize, error;
 198
 199         insize = SIZE(open_by_fd);
 200         UPARG(CODA_OPEN_BY_FD);
 201
 202         inp->coda_open_by_fd.VFid = *fid;
 203         inp->coda_open_by_fd.flags = flags;
 204
 205         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 206         if (!error)
 207                 *fh = outp->coda_open_by_fd.fh;
 208
 209         CODA_FREE(inp, insize);
 210         return error;
 211 }
 212
 213 int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid,
 214                    const char *name, int length,
 215                    struct CodaFid *newfid, struct coda_vattr *attrs)
 216 {
 217         union inputArgs *inp;
 218         union outputArgs *outp;
 219         int insize, outsize, error;
 220         int offset;
 221
 222         offset = INSIZE(mkdir);
 223         insize = max_t(unsigned int, offset + length + 1, OUTSIZE(mkdir));
 224         UPARG(CODA_MKDIR);
 225
 226         inp->coda_mkdir.VFid = *dirfid;
 227         inp->coda_mkdir.attr = *attrs;
 228         inp->coda_mkdir.name = offset;
 229         /* Venus must get null terminated string */
 230         memcpy((char *)(inp) + offset, name, length);
 231         *((char *)inp + offset + length) = '\0';
 232
 233         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 234         if (!error) {
 235                 *attrs = outp->coda_mkdir.attr;
 236                 *newfid = outp->coda_mkdir.VFid;
 237         }
 238
 239         CODA_FREE(inp, insize);
 240         return error;
 241 }
 242
 243
 244 int venus_rename(struct super_block *sb, struct CodaFid *old_fid,
 245                  struct CodaFid *new_fid, size_t old_length,
 246                  size_t new_length, const char *old_name,
 247                  const char *new_name)
 248 {
 249         union inputArgs *inp;
 250         union outputArgs *outp;
 251         int insize, outsize, error;
 252         int offset, s;
 253
 254         offset = INSIZE(rename);
 255         insize = max_t(unsigned int, offset + new_length + old_length + 8,
 256                      OUTSIZE(rename));
 257         UPARG(CODA_RENAME);
 258
 259         inp->coda_rename.sourceFid = *old_fid;
 260         inp->coda_rename.destFid =  *new_fid;
 261         inp->coda_rename.srcname = offset;
 262
 263         /* Venus must receive an null terminated string */
 264         s = ( old_length & ~0x3) +4; /* round up to word boundary */
 265         memcpy((char *)(inp) + offset, old_name, old_length);
 266         *((char *)inp + offset + old_length) = '\0';
 267
 268         /* another null terminated string for Venus */
 269         offset += s;
 270         inp->coda_rename.destname = offset;
 271         s = ( new_length & ~0x3) +4; /* round up to word boundary */
 272         memcpy((char *)(inp) + offset, new_name, new_length);
 273         *((char *)inp + offset + new_length) = '\0';
 274
 275         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 276
 277         CODA_FREE(inp, insize);
 278         return error;
 279 }
 280
 281 int venus_create(struct super_block *sb, struct CodaFid *dirfid,
 282                  const char *name, int length, int excl, int mode,
 283                  struct CodaFid *newfid, struct coda_vattr *attrs)
 284 {
 285         union inputArgs *inp;
 286         union outputArgs *outp;
 287         int insize, outsize, error;
 288         int offset;
 289
 290         offset = INSIZE(create);
 291         insize = max_t(unsigned int, offset + length + 1, OUTSIZE(create));
 292         UPARG(CODA_CREATE);
 293
 294         inp->coda_create.VFid = *dirfid;
 295         inp->coda_create.attr.va_mode = mode;
 296         inp->coda_create.excl = excl;
 297         inp->coda_create.mode = mode;
 298         inp->coda_create.name = offset;
 299
 300         /* Venus must get null terminated string */
 301         memcpy((char *)(inp) + offset, name, length);
 302         *((char *)inp + offset + length) = '\0';
 303
 304         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 305         if (!error) {
 306                 *attrs = outp->coda_create.attr;
 307                 *newfid = outp->coda_create.VFid;
 308         }
 309
 310         CODA_FREE(inp, insize);
 311         return error;
 312 }
 313
 314 int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid,
 315                     const char *name, int length)
 316 {
 317         union inputArgs *inp;
 318         union outputArgs *outp;
 319         int insize, outsize, error;
 320         int offset;
 321
 322         offset = INSIZE(rmdir);
 323         insize = max_t(unsigned int, offset + length + 1, OUTSIZE(rmdir));
 324         UPARG(CODA_RMDIR);
 325
 326         inp->coda_rmdir.VFid = *dirfid;
 327         inp->coda_rmdir.name = offset;
 328         memcpy((char *)(inp) + offset, name, length);
 329         *((char *)inp + offset + length) = '\0';
 330
 331         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 332
 333         CODA_FREE(inp, insize);
 334         return error;
 335 }
 336
 337 int venus_remove(struct super_block *sb, struct CodaFid *dirfid,
 338                     const char *name, int length)
 339 {
 340         union inputArgs *inp;
 341         union outputArgs *outp;
 342         int error=0, insize, outsize, offset;
 343
 344         offset = INSIZE(remove);
 345         insize = max_t(unsigned int, offset + length + 1, OUTSIZE(remove));
 346         UPARG(CODA_REMOVE);
 347
 348         inp->coda_remove.VFid = *dirfid;
 349         inp->coda_remove.name = offset;
 350         memcpy((char *)(inp) + offset, name, length);
 351         *((char *)inp + offset + length) = '\0';
 352
 353         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 354
 355         CODA_FREE(inp, insize);
 356         return error;
 357 }
 358
 359 int venus_readlink(struct super_block *sb, struct CodaFid *fid,
 360                       char *buffer, int *length)
 361 {
 362         union inputArgs *inp;
 363         union outputArgs *outp;
 364         int insize, outsize, error;
 365         int retlen;
 366         char *result;
 367
 368         insize = max_t(unsigned int,
 369                      INSIZE(readlink), OUTSIZE(readlink)+ *length + 1);
 370         UPARG(CODA_READLINK);
 371
 372         inp->coda_readlink.VFid = *fid;
 373
 374         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 375         if (!error) {
 376                 retlen = outp->coda_readlink.count;
 377                 if ( retlen > *length )
 378                         retlen = *length;
 379                 *length = retlen;
 380                 result =  (char *)outp + (long)outp->coda_readlink.data;
 381                 memcpy(buffer, result, retlen);
 382                 *(buffer + retlen) = '\0';
 383         }
 384
 385         CODA_FREE(inp, insize);
 386         return error;
 387 }
 388
 389
 390
 391 int venus_link(struct super_block *sb, struct CodaFid *fid,
 392                   struct CodaFid *dirfid, const char *name, int len )
 393 {
 394         union inputArgs *inp;
 395         union outputArgs *outp;
 396         int insize, outsize, error;
 397         int offset;
 398
 399         offset = INSIZE(link);
 400         insize = max_t(unsigned int, offset  + len + 1, OUTSIZE(link));
 401         UPARG(CODA_LINK);
 402
 403         inp->coda_link.sourceFid = *fid;
 404         inp->coda_link.destFid = *dirfid;
 405         inp->coda_link.tname = offset;
 406
 407         /* make sure strings are null terminated */
 408         memcpy((char *)(inp) + offset, name, len);
 409         *((char *)inp + offset + len) = '\0';
 410
 411         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 412
 413         CODA_FREE(inp, insize);
 414         return error;
 415 }
 416
 417 int venus_symlink(struct super_block *sb, struct CodaFid *fid,
 418                      const char *name, int len,
 419                      const char *symname, int symlen)
 420 {
 421         union inputArgs *inp;
 422         union outputArgs *outp;
 423         int insize, outsize, error;
 424         int offset, s;
 425
 426         offset = INSIZE(symlink);
 427         insize = max_t(unsigned int, offset + len + symlen + 8, OUTSIZE(symlink));
 428         UPARG(CODA_SYMLINK);
 429
 430         /*        inp->coda_symlink.attr = *tva; XXXXXX */
 431         inp->coda_symlink.VFid = *fid;
 432
 433         /* Round up to word boundary and null terminate */
 434         inp->coda_symlink.srcname = offset;
 435         s = ( symlen  & ~0x3 ) + 4;
 436         memcpy((char *)(inp) + offset, symname, symlen);
 437         *((char *)inp + offset + symlen) = '\0';
 438
 439         /* Round up to word boundary and null terminate */
 440         offset += s;
 441         inp->coda_symlink.tname = offset;
 442         s = (len & ~0x3) + 4;
 443         memcpy((char *)(inp) + offset, name, len);
 444         *((char *)inp + offset + len) = '\0';
 445
 446         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 447
 448         CODA_FREE(inp, insize);
 449         return error;
 450 }
 451
 452 int venus_fsync(struct super_block *sb, struct CodaFid *fid)
 453 {
 454         union inputArgs *inp;
 455         union outputArgs *outp;
 456         int insize, outsize, error;
 457
 458         insize=SIZE(fsync);
 459         UPARG(CODA_FSYNC);
 460
 461         inp->coda_fsync.VFid = *fid;
 462         error = coda_upcall(coda_vcp(sb), sizeof(union inputArgs),
 463                             &outsize, inp);
 464
 465         CODA_FREE(inp, insize);
 466         return error;
 467 }
 468
 469 int venus_access(struct super_block *sb, struct CodaFid *fid, int mask)
 470 {
 471         union inputArgs *inp;
 472         union outputArgs *outp;
 473         int insize, outsize, error;
 474
 475         insize = SIZE(access);
 476         UPARG(CODA_ACCESS);
 477
 478         inp->coda_access.VFid = *fid;
 479         inp->coda_access.flags = mask;
 480
 481         error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
 482
 483         CODA_FREE(inp, insize);
 484         return error;
 485 }
 486
 487
 488 int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
 489                  unsigned int cmd, struct PioctlData *data)
 490 {
 491         union inputArgs *inp;
 492         union outputArgs *outp;
 493         int insize, outsize, error;
 494         int iocsize;
 495
 496         insize = VC_MAXMSGSIZE;
 497         UPARG(CODA_IOCTL);
 498
 499         /* build packet for Venus */
 500         if (data->vi.in_size > VC_MAXDATASIZE) {
 501                 error = -EINVAL;
 502                 goto exit;
 503         }
 504
 505         if (data->vi.out_size > VC_MAXDATASIZE) {
 506                 error = -EINVAL;
 507                 goto exit;
 508         }
 509
 510         inp->coda_ioctl.VFid = *fid;
 511
 512         /* the cmd field was mutated by increasing its size field to
 513          * reflect the path and follow args. We need to subtract that
 514          * out before sending the command to Venus.  */
 515         inp->coda_ioctl.cmd = (cmd & ~(PIOCPARM_MASK << 16));
 516         iocsize = ((cmd >> 16) & PIOCPARM_MASK) - sizeof(char *) - sizeof(int);
 517         inp->coda_ioctl.cmd |= (iocsize & PIOCPARM_MASK) <<     16;
 518
 519         /* in->coda_ioctl.rwflag = flag; */
 520         inp->coda_ioctl.len = data->vi.in_size;
 521         inp->coda_ioctl.data = (char *)(INSIZE(ioctl));
 522
 523         /* get the data out of user space */
 524         if ( copy_from_user((char*)inp + (long)inp->coda_ioctl.data,
 525                             data->vi.in, data->vi.in_size) ) {
 526                 error = -EINVAL;
 527                 goto exit;
 528         }
 529
 530         error = coda_upcall(coda_vcp(sb), SIZE(ioctl) + data->vi.in_size,
 531                             &outsize, inp);
 532
 533         if (error) {
 534                 printk("coda_pioctl: Venus returns: %d for %s\n",
 535                        error, coda_f2s(fid));
 536                 goto exit;
 537         }
 538
 539         if (outsize < (long)outp->coda_ioctl.data + outp->coda_ioctl.len) {
 540                 error = -EINVAL;
 541                 goto exit;
 542         }
 543
 544         /* Copy out the OUT buffer. */
 545         if (outp->coda_ioctl.len > data->vi.out_size) {
 546                 error = -EINVAL;
 547                 goto exit;
 548         }
 549
 550         /* Copy out the OUT buffer. */
 551         if (copy_to_user(data->vi.out,
 552                          (char *)outp + (long)outp->coda_ioctl.data,
 553                          outp->coda_ioctl.len)) {
 554                 error = -EFAULT;
 555                 goto exit;
 556         }
 557
 558  exit:
 559         CODA_FREE(inp, insize);
 560         return error;
 561 }
 562
 563 int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
 564 {
 565         union inputArgs *inp;
 566         union outputArgs *outp;
 567         int insize, outsize, error;
 568
 569         insize = max_t(unsigned int, INSIZE(statfs), OUTSIZE(statfs));
 570         UPARG(CODA_STATFS);
 571
 572         error = coda_upcall(coda_vcp(dentry->d_sb), insize, &outsize, inp);
 573         if (!error) {
 574                 sfs->f_blocks = outp->coda_statfs.stat.f_blocks;
 575                 sfs->f_bfree  = outp->coda_statfs.stat.f_bfree;
 576                 sfs->f_bavail = outp->coda_statfs.stat.f_bavail;
 577                 sfs->f_files  = outp->coda_statfs.stat.f_files;
 578                 sfs->f_ffree  = outp->coda_statfs.stat.f_ffree;
 579         }
 580
 581         CODA_FREE(inp, insize);
 582         return error;
 583 }
 584
 585 /*
 586  * coda_upcall and coda_downcall routines.
 587  */
 588 static void coda_block_signals(sigset_t *old)
 589 {
 590         spin_lock_irq(&current->sighand->siglock);
 591         *old = current->blocked;
 592
 593         sigfillset(&current->blocked);
 594         sigdelset(&current->blocked, SIGKILL);
 595         sigdelset(&current->blocked, SIGSTOP);
 596         sigdelset(&current->blocked, SIGINT);
 597
 598         recalc_sigpending();
 599         spin_unlock_irq(&current->sighand->siglock);
 600 }
 601
 602 static void coda_unblock_signals(sigset_t *old)
 603 {
 604         spin_lock_irq(&current->sighand->siglock);
 605         current->blocked = *old;
 606         recalc_sigpending();
 607         spin_unlock_irq(&current->sighand->siglock);
 608 }
 609
 610 /* Don't allow signals to interrupt the following upcalls before venus
 611  * has seen them,
 612  * - CODA_CLOSE or CODA_RELEASE upcall  (to avoid reference count problems)
 613  * - CODA_STORE                         (to avoid data loss)
 614  */
 615 #define CODA_INTERRUPTIBLE(r) (!coda_hard && \
 616                                (((r)->uc_opcode != CODA_CLOSE && \
 617                                  (r)->uc_opcode != CODA_STORE && \
 618                                  (r)->uc_opcode != CODA_RELEASE) || \
 619                                 (r)->uc_flags & REQ_READ))
 620
 621 static inline void coda_waitfor_upcall(struct upc_req *req)
 622 {
 623         DECLARE_WAITQUEUE(wait, current);
 624         unsigned long timeout = jiffies + coda_timeout * HZ;
 625         sigset_t old;
 626         int blocked;
 627
 628         coda_block_signals(&old);
 629         blocked = 1;
 630
 631         add_wait_queue(&req->uc_sleep, &wait);
 632         for (;;) {
 633                 if (CODA_INTERRUPTIBLE(req))
 634                         set_current_state(TASK_INTERRUPTIBLE);
 635                 else
 636                         set_current_state(TASK_UNINTERRUPTIBLE);
 637
 638                 /* got a reply */
 639                 if (req->uc_flags & (REQ_WRITE | REQ_ABORT))
 640                         break;
 641
 642                 if (blocked && time_after(jiffies, timeout) &&
 643                     CODA_INTERRUPTIBLE(req))
 644                 {
 645                         coda_unblock_signals(&old);
 646                         blocked = 0;
 647                 }
 648
 649                 if (signal_pending(current)) {
 650                         list_del(&req->uc_chain);
 651                         break;
 652                 }
 653
 654                 if (blocked)
 655                         schedule_timeout(HZ);
 656                 else
 657                         schedule();
 658         }
 659         if (blocked)
 660                 coda_unblock_signals(&old);
 661
 662         remove_wait_queue(&req->uc_sleep, &wait);
 663         set_current_state(TASK_RUNNING);
 664 }
 665
 666
 667 /*
 668  * coda_upcall will return an error in the case of
 669  * failed communication with Venus _or_ will peek at Venus
 670  * reply and return Venus' error.
 671  *
 672  * As venus has 2 types of errors, normal errors (positive) and internal
 673  * errors (negative), normal errors are negated, while internal errors
 674  * are all mapped to -EINTR, while showing a nice warning message. (jh)
 675  */
 676 static int coda_upcall(struct venus_comm *vcp,
 677                        int inSize, int *outSize,
 678                        union inputArgs *buffer)
 679 {
 680         union outputArgs *out;
 681         union inputArgs *sig_inputArgs;
 682         struct upc_req *req, *sig_req;
 683         int error = 0;
 684
 685         if (!vcp->vc_inuse) {
 686                 printk(KERN_NOTICE "coda: Venus dead, not sending upcall\n");
 687                 return -ENXIO;
 688         }
 689
 690         /* Format the request message. */
 691         req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
 692         if (!req)
 693                 return -ENOMEM;
 694
 695         req->uc_data = (void *)buffer;
 696         req->uc_flags = 0;
 697         req->uc_inSize = inSize;
 698         req->uc_outSize = *outSize ? *outSize : inSize;
 699         req->uc_opcode = ((union inputArgs *)buffer)->ih.opcode;
 700         req->uc_unique = ++vcp->vc_seq;
 701         init_waitqueue_head(&req->uc_sleep);
 702
 703         /* Fill in the common input args. */
 704         ((union inputArgs *)buffer)->ih.unique = req->uc_unique;
 705
 706         /* Append msg to pending queue and poke Venus. */
 707         list_add_tail(&req->uc_chain, &vcp->vc_pending);
 708
 709         wake_up_interruptible(&vcp->vc_waitq);
 710         /* We can be interrupted while we wait for Venus to process
 711          * our request.  If the interrupt occurs before Venus has read
 712          * the request, we dequeue and return. If it occurs after the
 713          * read but before the reply, we dequeue, send a signal
 714          * message, and return. If it occurs after the reply we ignore
 715          * it. In no case do we want to restart the syscall.  If it
 716          * was interrupted by a venus shutdown (psdev_close), return
 717          * ENODEV.  */
 718
 719         /* Go to sleep.  Wake up on signals only after the timeout. */
 720         coda_waitfor_upcall(req);
 721
 722         /* Op went through, interrupt or not... */
 723         if (req->uc_flags & REQ_WRITE) {
 724                 out = (union outputArgs *)req->uc_data;
 725                 /* here we map positive Venus errors to kernel errors */
 726                 error = -out->oh.result;
 727                 *outSize = req->uc_outSize;
 728                 goto exit;
 729         }
 730
 731         error = -EINTR;
 732         if ((req->uc_flags & REQ_ABORT) || !signal_pending(current)) {
 733                 printk(KERN_WARNING "coda: Unexpected interruption.\n");
 734                 goto exit;
 735         }
 736
 737         /* Interrupted before venus read it. */
 738         if (!(req->uc_flags & REQ_READ))
 739                 goto exit;
 740
 741         /* Venus saw the upcall, make sure we can send interrupt signal */
 742         if (!vcp->vc_inuse) {
 743                 printk(KERN_INFO "coda: Venus dead, not sending signal.\n");
 744                 goto exit;
 745         }
 746
 747         error = -ENOMEM;
 748         sig_req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
 749         if (!sig_req) goto exit;
 750
 751         CODA_ALLOC((sig_req->uc_data), char *, sizeof(struct coda_in_hdr));
 752         if (!sig_req->uc_data) {
 753                 kfree(sig_req);
 754                 goto exit;
 755         }
 756
 757         error = -EINTR;
 758         sig_inputArgs = (union inputArgs *)sig_req->uc_data;
 759         sig_inputArgs->ih.opcode = CODA_SIGNAL;
 760         sig_inputArgs->ih.unique = req->uc_unique;
 761
 762         sig_req->uc_flags = REQ_ASYNC;
 763         sig_req->uc_opcode = sig_inputArgs->ih.opcode;
 764         sig_req->uc_unique = sig_inputArgs->ih.unique;
 765         sig_req->uc_inSize = sizeof(struct coda_in_hdr);
 766         sig_req->uc_outSize = sizeof(struct coda_in_hdr);
 767
 768         /* insert at head of queue! */
 769         list_add(&(sig_req->uc_chain), &vcp->vc_pending);
 770         wake_up_interruptible(&vcp->vc_waitq);
 771
 772 exit:
 773         kfree(req);
 774         return error;
 775 }
 776
 777 /*
 778     The statements below are part of the Coda opportunistic
 779     programming -- taken from the Mach/BSD kernel code for Coda.
 780     You don't get correct semantics by stating what needs to be
 781     done without guaranteeing the invariants needed for it to happen.
 782     When will be have time to find out what exactly is going on?  (pjb)
 783 */
 784
 785
 786 /*
 787  * There are 7 cases where cache invalidations occur.  The semantics
 788  *  of each is listed here:
 789  *
 790  * CODA_FLUSH     -- flush all entries from the name cache and the cnode cache.
 791  * CODA_PURGEUSER -- flush all entries from the name cache for a specific user
 792  *                  This call is a result of token expiration.
 793  *
 794  * The next arise as the result of callbacks on a file or directory.
 795  * CODA_ZAPFILE   -- flush the cached attributes for a file.
 796
 797  * CODA_ZAPDIR    -- flush the attributes for the dir and
 798  *                  force a new lookup for all the children
 799                     of this dir.
 800
 801  *
 802  * The next is a result of Venus detecting an inconsistent file.
 803  * CODA_PURGEFID  -- flush the attribute for the file
 804  *                  purge it and its children from the dcache
 805  *
 806  * The last  allows Venus to replace local fids with global ones
 807  * during reintegration.
 808  *
 809  * CODA_REPLACE -- replace one CodaFid with another throughout the name cache */
 810
 811 int coda_downcall(int opcode, union outputArgs * out, struct super_block *sb)
 812 {
 813         struct inode *inode = NULL;
 814         struct CodaFid *fid, *newfid;
 815
 816         /* Handle invalidation requests. */
 817         if ( !sb || !sb->s_root)
 818                 return 0;
 819
 820         switch (opcode) {
 821         case CODA_FLUSH:
 822                 coda_cache_clear_all(sb);
 823                 shrink_dcache_sb(sb);
 824                 if (sb->s_root->d_inode)
 825                     coda_flag_inode(sb->s_root->d_inode, C_FLUSH);
 826                 break;
 827
 828         case CODA_PURGEUSER:
 829                 coda_cache_clear_all(sb);
 830                 break;
 831
 832         case CODA_ZAPDIR:
 833                 fid = &out->coda_zapdir.CodaFid;
 834                 inode = coda_fid_to_inode(fid, sb);
 835                 if (inode) {
 836                         coda_flag_inode_children(inode, C_PURGE);
 837                         coda_flag_inode(inode, C_VATTR);
 838                 }
 839                 break;
 840
 841         case CODA_ZAPFILE:
 842                 fid = &out->coda_zapfile.CodaFid;
 843                 inode = coda_fid_to_inode(fid, sb);
 844                 if (inode)
 845                         coda_flag_inode(inode, C_VATTR);
 846                 break;
 847
 848         case CODA_PURGEFID:
 849                 fid = &out->coda_purgefid.CodaFid;
 850                 inode = coda_fid_to_inode(fid, sb);
 851                 if (inode) {
 852                         coda_flag_inode_children(inode, C_PURGE);
 853
 854                         /* catch the dentries later if some are still busy */
 855                         coda_flag_inode(inode, C_PURGE);
 856                         d_prune_aliases(inode);
 857
 858                 }
 859                 break;
 860
 861         case CODA_REPLACE:
 862                 fid = &out->coda_replace.OldFid;
 863                 newfid = &out->coda_replace.NewFid;
 864                 inode = coda_fid_to_inode(fid, sb);
 865                 if (inode)
 866                         coda_replace_fid(inode, fid, newfid);
 867                 break;
 868         }
 869
 870         if (inode)
 871                 iput(inode);
 872
 873         return 0;
 874 }
 875