fs/nfsd/export.c

   1 #define MSNFS   /* HACK HACK */
   2 /*
   3  * linux/fs/nfsd/export.c
   4  *
   5  * NFS exporting and validation.
   6  *
   7  * We maintain a list of clients, each of which has a list of
   8  * exports. To export an fs to a given client, you first have
   9  * to create the client entry with NFSCTL_ADDCLIENT, which
  10  * creates a client control block and adds it to the hash
  11  * table. Then, you call NFSCTL_EXPORT for each fs.
  12  *
  13  *
  14  * Copyright (C) 1995, 1996 Olaf Kirch, <okir@monad.swb.de>
  15  */
  16
  17 #include <linux/unistd.h>
  18 #include <linux/slab.h>
  19 #include <linux/sched.h>
  20 #include <linux/stat.h>
  21 #include <linux/in.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/syscalls.h>
  24 #include <linux/rwsem.h>
  25 #include <linux/dcache.h>
  26 #include <linux/namei.h>
  27 #include <linux/mount.h>
  28 #include <linux/hash.h>
  29 #include <linux/module.h>
  30
  31 #include <linux/sunrpc/svc.h>
  32 #include <linux/nfsd/nfsd.h>
  33 #include <linux/nfsd/nfsfh.h>
  34 #include <linux/nfsd/syscall.h>
  35 #include <linux/lockd/bind.h>
  36
  37 #define NFSDDBG_FACILITY        NFSDDBG_EXPORT
  38 #define NFSD_PARANOIA 1
  39
  40 typedef struct auth_domain      svc_client;
  41 typedef struct svc_export       svc_export;
  42
  43 static void             exp_do_unexport(svc_export *unexp);
  44 static int              exp_verify_string(char *cp, int max);
  45
  46 /*
  47  * We have two caches.
  48  * One maps client+vfsmnt+dentry to export options - the export map
  49  * The other maps client+filehandle-fragment to export options. - the expkey map
  50  *
  51  * The export options are actually stored in the first map, and the
  52  * second map contains a reference to the entry in the first map.
  53  */
  54
  55 #define EXPKEY_HASHBITS         8
  56 #define EXPKEY_HASHMAX          (1 << EXPKEY_HASHBITS)
  57 #define EXPKEY_HASHMASK         (EXPKEY_HASHMAX -1)
  58 static struct cache_head *expkey_table[EXPKEY_HASHMAX];
  59
  60 static inline int svc_expkey_hash(struct svc_expkey *item)
  61 {
  62         int hash = item->ek_fsidtype;
  63         char * cp = (char*)item->ek_fsid;
  64         int len = key_len(item->ek_fsidtype);
  65
  66         hash ^= hash_mem(cp, len, EXPKEY_HASHBITS);
  67         hash ^= hash_ptr(item->ek_client, EXPKEY_HASHBITS);
  68         return hash & EXPKEY_HASHMASK;
  69 }
  70
  71 void expkey_put(struct cache_head *item, struct cache_detail *cd)
  72 {
  73         if (cache_put(item, cd)) {
  74                 struct svc_expkey *key = container_of(item, struct svc_expkey, h);
  75                 if (test_bit(CACHE_VALID, &item->flags) &&
  76                     !test_bit(CACHE_NEGATIVE, &item->flags)) {
  77                         dput(key->ek_dentry);
  78                         mntput(key->ek_mnt);
  79                 }
  80                 auth_domain_put(key->ek_client);
  81                 kfree(key);
  82         }
  83 }
  84
  85 static void expkey_request(struct cache_detail *cd,
  86                            struct cache_head *h,
  87                            char **bpp, int *blen)
  88 {
  89         /* client fsidtype \xfsid */
  90         struct svc_expkey *ek = container_of(h, struct svc_expkey, h);
  91         char type[5];
  92
  93         qword_add(bpp, blen, ek->ek_client->name);
  94         snprintf(type, 5, "%d", ek->ek_fsidtype);
  95         qword_add(bpp, blen, type);
  96         qword_addhex(bpp, blen, (char*)ek->ek_fsid, key_len(ek->ek_fsidtype));
  97         (*bpp)[-1] = '\n';
  98 }
  99
 100 static struct svc_expkey *svc_expkey_lookup(struct svc_expkey *, int);
 101 static int expkey_parse(struct cache_detail *cd, char *mesg, int mlen)
 102 {
 103         /* client fsidtype fsid [path] */
 104         char *buf;
 105         int len;
 106         struct auth_domain *dom = NULL;
 107         int err;
 108         int fsidtype;
 109         char *ep;
 110         struct svc_expkey key;
 111
 112         if (mesg[mlen-1] != '\n')
 113                 return -EINVAL;
 114         mesg[mlen-1] = 0;
 115
 116         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 117         err = -ENOMEM;
 118         if (!buf) goto out;
 119
 120         err = -EINVAL;
 121         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
 122                 goto out;
 123
 124         err = -ENOENT;
 125         dom = auth_domain_find(buf);
 126         if (!dom)
 127                 goto out;
 128         dprintk("found domain %s\n", buf);
 129
 130         err = -EINVAL;
 131         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
 132                 goto out;
 133         fsidtype = simple_strtoul(buf, &ep, 10);
 134         if (*ep)
 135                 goto out;
 136         dprintk("found fsidtype %d\n", fsidtype);
 137         if (fsidtype > 2)
 138                 goto out;
 139         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
 140                 goto out;
 141         dprintk("found fsid length %d\n", len);
 142         if (len != key_len(fsidtype))
 143                 goto out;
 144
 145         /* OK, we seem to have a valid key */
 146         key.h.flags = 0;
 147         key.h.expiry_time = get_expiry(&mesg);
 148         if (key.h.expiry_time == 0)
 149                 goto out;
 150
 151         key.ek_client = dom;
 152         key.ek_fsidtype = fsidtype;
 153         memcpy(key.ek_fsid, buf, len);
 154
 155         /* now we want a pathname, or empty meaning NEGATIVE  */
 156         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) < 0)
 157                 goto out;
 158         dprintk("Path seems to be <%s>\n", buf);
 159         err = 0;
 160         if (len == 0) {
 161                 struct svc_expkey *ek;
 162                 set_bit(CACHE_NEGATIVE, &key.h.flags);
 163                 ek = svc_expkey_lookup(&key, 1);
 164                 if (ek)
 165                         expkey_put(&ek->h, &svc_expkey_cache);
 166         } else {
 167                 struct nameidata nd;
 168                 struct svc_expkey *ek;
 169                 err = path_lookup(buf, 0, &nd);
 170                 if (err)
 171                         goto out;
 172
 173                 dprintk("Found the path %s\n", buf);
 174                 key.ek_mnt = nd.mnt;
 175                 key.ek_dentry = nd.dentry;
 176
 177                 ek = svc_expkey_lookup(&key, 1);
 178                 if (ek)
 179                         expkey_put(&ek->h, &svc_expkey_cache);
 180                 err = 0;
 181                 path_release(&nd);
 182         }
 183         cache_flush();
 184  out:
 185         if (dom)
 186                 auth_domain_put(dom);
 187         kfree(buf);
 188         return err;
 189 }
 190
 191 static int expkey_show(struct seq_file *m,
 192                        struct cache_detail *cd,
 193                        struct cache_head *h)
 194 {
 195         struct svc_expkey *ek ;
 196
 197         if (h ==NULL) {
 198                 seq_puts(m, "#domain fsidtype fsid [path]\n");
 199                 return 0;
 200         }
 201         ek = container_of(h, struct svc_expkey, h);
 202         seq_printf(m, "%s %d 0x%08x", ek->ek_client->name,
 203                    ek->ek_fsidtype, ek->ek_fsid[0]);
 204         if (ek->ek_fsidtype != 1)
 205                 seq_printf(m, "%08x", ek->ek_fsid[1]);
 206         if (ek->ek_fsidtype == 2)
 207                 seq_printf(m, "%08x", ek->ek_fsid[2]);
 208         if (test_bit(CACHE_VALID, &h->flags) &&
 209             !test_bit(CACHE_NEGATIVE, &h->flags)) {
 210                 seq_printf(m, " ");
 211                 seq_path(m, ek->ek_mnt, ek->ek_dentry, "\\ \t\n");
 212         }
 213         seq_printf(m, "\n");
 214         return 0;
 215 }
 216
 217 struct cache_detail svc_expkey_cache = {
 218         .owner          = THIS_MODULE,
 219         .hash_size      = EXPKEY_HASHMAX,
 220         .hash_table     = expkey_table,
 221         .name           = "nfsd.fh",
 222         .cache_put      = expkey_put,
 223         .cache_request  = expkey_request,
 224         .cache_parse    = expkey_parse,
 225         .cache_show     = expkey_show,
 226 };
 227
 228 static inline int svc_expkey_match (struct svc_expkey *a, struct svc_expkey *b)
 229 {
 230         if (a->ek_fsidtype != b->ek_fsidtype ||
 231             a->ek_client != b->ek_client ||
 232             memcmp(a->ek_fsid, b->ek_fsid, key_len(a->ek_fsidtype)) != 0)
 233                 return 0;
 234         return 1;
 235 }
 236
 237 static inline void svc_expkey_init(struct svc_expkey *new, struct svc_expkey *item)
 238 {
 239         kref_get(&item->ek_client->ref);
 240         new->ek_client = item->ek_client;
 241         new->ek_fsidtype = item->ek_fsidtype;
 242         new->ek_fsid[0] = item->ek_fsid[0];
 243         new->ek_fsid[1] = item->ek_fsid[1];
 244         new->ek_fsid[2] = item->ek_fsid[2];
 245 }
 246
 247 static inline void svc_expkey_update(struct svc_expkey *new, struct svc_expkey *item)
 248 {
 249         new->ek_mnt = mntget(item->ek_mnt);
 250         new->ek_dentry = dget(item->ek_dentry);
 251 }
 252
 253 static DefineSimpleCacheLookup(svc_expkey,0) /* no inplace updates */
 254
 255 #define EXPORT_HASHBITS         8
 256 #define EXPORT_HASHMAX          (1<< EXPORT_HASHBITS)
 257 #define EXPORT_HASHMASK         (EXPORT_HASHMAX -1)
 258
 259 static struct cache_head *export_table[EXPORT_HASHMAX];
 260
 261 static inline int svc_export_hash(struct svc_export *item)
 262 {
 263         int rv;
 264
 265         rv = hash_ptr(item->ex_client, EXPORT_HASHBITS);
 266         rv ^= hash_ptr(item->ex_dentry, EXPORT_HASHBITS);
 267         rv ^= hash_ptr(item->ex_mnt, EXPORT_HASHBITS);
 268         return rv;
 269 }
 270
 271 void svc_export_put(struct cache_head *item, struct cache_detail *cd)
 272 {
 273         if (cache_put(item, cd)) {
 274                 struct svc_export *exp = container_of(item, struct svc_export, h);
 275                 dput(exp->ex_dentry);
 276                 mntput(exp->ex_mnt);
 277                 auth_domain_put(exp->ex_client);
 278                 kfree(exp);
 279         }
 280 }
 281
 282 static void svc_export_request(struct cache_detail *cd,
 283                                struct cache_head *h,
 284                                char **bpp, int *blen)
 285 {
 286         /*  client path */
 287         struct svc_export *exp = container_of(h, struct svc_export, h);
 288         char *pth;
 289
 290         qword_add(bpp, blen, exp->ex_client->name);
 291         pth = d_path(exp->ex_dentry, exp->ex_mnt, *bpp, *blen);
 292         if (IS_ERR(pth)) {
 293                 /* is this correct? */
 294                 (*bpp)[0] = '\n';
 295                 return;
 296         }
 297         qword_add(bpp, blen, pth);
 298         (*bpp)[-1] = '\n';
 299 }
 300
 301 static struct svc_export *svc_export_lookup(struct svc_export *, int);
 302
 303 static int check_export(struct inode *inode, int flags)
 304 {
 305
 306         /* We currently export only dirs and regular files.
 307          * This is what umountd does.
 308          */
 309         if (!S_ISDIR(inode->i_mode) &&
 310             !S_ISREG(inode->i_mode))
 311                 return -ENOTDIR;
 312
 313         /* There are two requirements on a filesystem to be exportable.
 314          * 1:  We must be able to identify the filesystem from a number.
 315          *       either a device number (so FS_REQUIRES_DEV needed)
 316          *       or an FSID number (so NFSEXP_FSID needed).
 317          * 2:  We must be able to find an inode from a filehandle.
 318          *       This means that s_export_op must be set.
 319          */
 320         if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) &&
 321             !(flags & NFSEXP_FSID)) {
 322                 dprintk("exp_export: export of non-dev fs without fsid");
 323                 return -EINVAL;
 324         }
 325         if (!inode->i_sb->s_export_op) {
 326                 dprintk("exp_export: export of invalid fs type.\n");
 327                 return -EINVAL;
 328         }
 329
 330         /* Ok, we can export it */;
 331         if (!inode->i_sb->s_export_op->find_exported_dentry)
 332                 inode->i_sb->s_export_op->find_exported_dentry =
 333                         find_exported_dentry;
 334         return 0;
 335
 336 }
 337
 338 static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 339 {
 340         /* client path expiry [flags anonuid anongid fsid] */
 341         char *buf;
 342         int len;
 343         int err;
 344         struct auth_domain *dom = NULL;
 345         struct nameidata nd;
 346         struct svc_export exp, *expp;
 347         int an_int;
 348
 349         nd.dentry = NULL;
 350
 351         if (mesg[mlen-1] != '\n')
 352                 return -EINVAL;
 353         mesg[mlen-1] = 0;
 354
 355         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 356         err = -ENOMEM;
 357         if (!buf) goto out;
 358
 359         /* client */
 360         len = qword_get(&mesg, buf, PAGE_SIZE);
 361         err = -EINVAL;
 362         if (len <= 0) goto out;
 363
 364         err = -ENOENT;
 365         dom = auth_domain_find(buf);
 366         if (!dom)
 367                 goto out;
 368
 369         /* path */
 370         err = -EINVAL;
 371         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
 372                 goto out;
 373         err = path_lookup(buf, 0, &nd);
 374         if (err) goto out;
 375
 376         exp.h.flags = 0;
 377         exp.ex_client = dom;
 378         exp.ex_mnt = nd.mnt;
 379         exp.ex_dentry = nd.dentry;
 380
 381         /* expiry */
 382         err = -EINVAL;
 383         exp.h.expiry_time = get_expiry(&mesg);
 384         if (exp.h.expiry_time == 0)
 385                 goto out;
 386
 387         /* flags */
 388         err = get_int(&mesg, &an_int);
 389         if (err == -ENOENT)
 390                 set_bit(CACHE_NEGATIVE, &exp.h.flags);
 391         else {
 392                 if (err || an_int < 0) goto out;
 393                 exp.ex_flags= an_int;
 394
 395                 /* anon uid */
 396                 err = get_int(&mesg, &an_int);
 397                 if (err) goto out;
 398                 exp.ex_anon_uid= an_int;
 399
 400                 /* anon gid */
 401                 err = get_int(&mesg, &an_int);
 402                 if (err) goto out;
 403                 exp.ex_anon_gid= an_int;
 404
 405                 /* fsid */
 406                 err = get_int(&mesg, &an_int);
 407                 if (err) goto out;
 408                 exp.ex_fsid = an_int;
 409
 410                 err = check_export(nd.dentry->d_inode, exp.ex_flags);
 411                 if (err) goto out;
 412         }
 413
 414         expp = svc_export_lookup(&exp, 1);
 415         if (expp)
 416                 exp_put(expp);
 417         err = 0;
 418         cache_flush();
 419  out:
 420         if (nd.dentry)
 421                 path_release(&nd);
 422         if (dom)
 423                 auth_domain_put(dom);
 424         kfree(buf);
 425         return err;
 426 }
 427
 428 static void exp_flags(struct seq_file *m, int flag, int fsid, uid_t anonu, uid_t anong);
 429
 430 static int svc_export_show(struct seq_file *m,
 431                            struct cache_detail *cd,
 432                            struct cache_head *h)
 433 {
 434         struct svc_export *exp ;
 435
 436         if (h ==NULL) {
 437                 seq_puts(m, "#path domain(flags)\n");
 438                 return 0;
 439         }
 440         exp = container_of(h, struct svc_export, h);
 441         seq_path(m, exp->ex_mnt, exp->ex_dentry, " \t\n\\");
 442         seq_putc(m, '\t');
 443         seq_escape(m, exp->ex_client->name, " \t\n\\");
 444         seq_putc(m, '(');
 445         if (test_bit(CACHE_VALID, &h->flags) &&
 446             !test_bit(CACHE_NEGATIVE, &h->flags))
 447                 exp_flags(m, exp->ex_flags, exp->ex_fsid,
 448                           exp->ex_anon_uid, exp->ex_anon_gid);
 449         seq_puts(m, ")\n");
 450         return 0;
 451 }
 452 struct cache_detail svc_export_cache = {
 453         .owner          = THIS_MODULE,
 454         .hash_size      = EXPORT_HASHMAX,
 455         .hash_table     = export_table,
 456         .name           = "nfsd.export",
 457         .cache_put      = svc_export_put,
 458         .cache_request  = svc_export_request,
 459         .cache_parse    = svc_export_parse,
 460         .cache_show     = svc_export_show,
 461 };
 462
 463 static inline int svc_export_match(struct svc_export *a, struct svc_export *b)
 464 {
 465         return a->ex_client == b->ex_client &&
 466                 a->ex_dentry == b->ex_dentry &&
 467                 a->ex_mnt == b->ex_mnt;
 468 }
 469 static inline void svc_export_init(struct svc_export *new, struct svc_export *item)
 470 {
 471         kref_get(&item->ex_client->ref);
 472         new->ex_client = item->ex_client;
 473         new->ex_dentry = dget(item->ex_dentry);
 474         new->ex_mnt = mntget(item->ex_mnt);
 475 }
 476
 477 static inline void svc_export_update(struct svc_export *new, struct svc_export *item)
 478 {
 479         new->ex_flags = item->ex_flags;
 480         new->ex_anon_uid = item->ex_anon_uid;
 481         new->ex_anon_gid = item->ex_anon_gid;
 482         new->ex_fsid = item->ex_fsid;
 483 }
 484
 485 static DefineSimpleCacheLookup(svc_export,1) /* allow inplace updates */
 486
 487
 488 struct svc_expkey *
 489 exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
 490 {
 491         struct svc_expkey key, *ek;
 492         int err;
 493
 494         if (!clp)
 495                 return NULL;
 496
 497         key.ek_client = clp;
 498         key.ek_fsidtype = fsid_type;
 499         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 500
 501         ek = svc_expkey_lookup(&key, 0);
 502         if (ek != NULL)
 503                 if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
 504                         ek = ERR_PTR(err);
 505         return ek;
 506 }
 507
 508 static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
 509                        struct svc_export *exp)
 510 {
 511         struct svc_expkey key, *ek;
 512
 513         key.ek_client = clp;
 514         key.ek_fsidtype = fsid_type;
 515         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 516         key.ek_mnt = exp->ex_mnt;
 517         key.ek_dentry = exp->ex_dentry;
 518         key.h.expiry_time = NEVER;
 519         key.h.flags = 0;
 520
 521         ek = svc_expkey_lookup(&key, 1);
 522         if (ek) {
 523                 expkey_put(&ek->h, &svc_expkey_cache);
 524                 return 0;
 525         }
 526         return -ENOMEM;
 527 }
 528
 529 /*
 530  * Find the client's export entry matching xdev/xino.
 531  */
 532 static inline struct svc_expkey *
 533 exp_get_key(svc_client *clp, dev_t dev, ino_t ino)
 534 {
 535         u32 fsidv[3];
 536
 537         if (old_valid_dev(dev)) {
 538                 mk_fsid_v0(fsidv, dev, ino);
 539                 return exp_find_key(clp, 0, fsidv, NULL);
 540         }
 541         mk_fsid_v3(fsidv, dev, ino);
 542         return exp_find_key(clp, 3, fsidv, NULL);
 543 }
 544
 545 /*
 546  * Find the client's export entry matching fsid
 547  */
 548 static inline struct svc_expkey *
 549 exp_get_fsid_key(svc_client *clp, int fsid)
 550 {
 551         u32 fsidv[2];
 552
 553         mk_fsid_v1(fsidv, fsid);
 554
 555         return exp_find_key(clp, 1, fsidv, NULL);
 556 }
 557
 558 svc_export *
 559 exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
 560                 struct cache_req *reqp)
 561 {
 562         struct svc_export *exp, key;
 563
 564         if (!clp)
 565                 return NULL;
 566
 567         key.ex_client = clp;
 568         key.ex_mnt = mnt;
 569         key.ex_dentry = dentry;
 570
 571         exp = svc_export_lookup(&key, 0);
 572         if (exp != NULL)
 573                 switch (cache_check(&svc_export_cache, &exp->h, reqp)) {
 574                 case 0: break;
 575                 case -EAGAIN:
 576                         exp = ERR_PTR(-EAGAIN);
 577                         break;
 578                 default:
 579                         exp = NULL;
 580                 }
 581
 582         return exp;
 583 }
 584
 585 /*
 586  * Find the export entry for a given dentry.
 587  */
 588 struct svc_export *
 589 exp_parent(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
 590            struct cache_req *reqp)
 591 {
 592         svc_export *exp;
 593
 594         dget(dentry);
 595         exp = exp_get_by_name(clp, mnt, dentry, reqp);
 596
 597         while (exp == NULL && !IS_ROOT(dentry)) {
 598                 struct dentry *parent;
 599
 600                 parent = dget_parent(dentry);
 601                 dput(dentry);
 602                 dentry = parent;
 603                 exp = exp_get_by_name(clp, mnt, dentry, reqp);
 604         }
 605         dput(dentry);
 606         return exp;
 607 }
 608
 609 /*
 610  * Hashtable locking. Write locks are placed only by user processes
 611  * wanting to modify export information.
 612  * Write locking only done in this file.  Read locking
 613  * needed externally.
 614  */
 615
 616 static DECLARE_RWSEM(hash_sem);
 617
 618 void
 619 exp_readlock(void)
 620 {
 621         down_read(&hash_sem);
 622 }
 623
 624 static inline void
 625 exp_writelock(void)
 626 {
 627         down_write(&hash_sem);
 628 }
 629
 630 void
 631 exp_readunlock(void)
 632 {
 633         up_read(&hash_sem);
 634 }
 635
 636 static inline void
 637 exp_writeunlock(void)
 638 {
 639         up_write(&hash_sem);
 640 }
 641
 642 static void exp_fsid_unhash(struct svc_export *exp)
 643 {
 644         struct svc_expkey *ek;
 645
 646         if ((exp->ex_flags & NFSEXP_FSID) == 0)
 647                 return;
 648
 649         ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
 650         if (ek && !IS_ERR(ek)) {
 651                 ek->h.expiry_time = get_seconds()-1;
 652                 expkey_put(&ek->h, &svc_expkey_cache);
 653         }
 654         svc_expkey_cache.nextcheck = get_seconds();
 655 }
 656
 657 static int exp_fsid_hash(svc_client *clp, struct svc_export *exp)
 658 {
 659         u32 fsid[2];
 660
 661         if ((exp->ex_flags & NFSEXP_FSID) == 0)
 662                 return 0;
 663
 664         mk_fsid_v1(fsid, exp->ex_fsid);
 665         return exp_set_key(clp, 1, fsid, exp);
 666 }
 667
 668 static int exp_hash(struct auth_domain *clp, struct svc_export *exp)
 669 {
 670         u32 fsid[2];
 671         struct inode *inode = exp->ex_dentry->d_inode;
 672         dev_t dev = inode->i_sb->s_dev;
 673
 674         if (old_valid_dev(dev)) {
 675                 mk_fsid_v0(fsid, dev, inode->i_ino);
 676                 return exp_set_key(clp, 0, fsid, exp);
 677         }
 678         mk_fsid_v3(fsid, dev, inode->i_ino);
 679         return exp_set_key(clp, 3, fsid, exp);
 680 }
 681
 682 static void exp_unhash(struct svc_export *exp)
 683 {
 684         struct svc_expkey *ek;
 685         struct inode *inode = exp->ex_dentry->d_inode;
 686
 687         ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
 688         if (ek && !IS_ERR(ek)) {
 689                 ek->h.expiry_time = get_seconds()-1;
 690                 expkey_put(&ek->h, &svc_expkey_cache);
 691         }
 692         svc_expkey_cache.nextcheck = get_seconds();
 693 }
 694
 695 /*
 696  * Export a file system.
 697  */
 698 int
 699 exp_export(struct nfsctl_export *nxp)
 700 {
 701         svc_client      *clp;
 702         struct svc_export       *exp = NULL;
 703         struct svc_export       new;
 704         struct svc_expkey       *fsid_key = NULL;
 705         struct nameidata nd;
 706         int             err;
 707
 708         /* Consistency check */
 709         err = -EINVAL;
 710         if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
 711             !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
 712                 goto out;
 713
 714         dprintk("exp_export called for %s:%s (%x/%ld fl %x).\n",
 715                         nxp->ex_client, nxp->ex_path,
 716                         (unsigned)nxp->ex_dev, (long)nxp->ex_ino,
 717                         nxp->ex_flags);
 718
 719         /* Try to lock the export table for update */
 720         exp_writelock();
 721
 722         /* Look up client info */
 723         if (!(clp = auth_domain_find(nxp->ex_client)))
 724                 goto out_unlock;
 725
 726
 727         /* Look up the dentry */
 728         err = path_lookup(nxp->ex_path, 0, &nd);
 729         if (err)
 730                 goto out_unlock;
 731         err = -EINVAL;
 732
 733         exp = exp_get_by_name(clp, nd.mnt, nd.dentry, NULL);
 734
 735         /* must make sure there won't be an ex_fsid clash */
 736         if ((nxp->ex_flags & NFSEXP_FSID) &&
 737             (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
 738             !IS_ERR(fsid_key) &&
 739             fsid_key->ek_mnt &&
 740             (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
 741                 goto finish;
 742
 743         if (exp) {
 744                 /* just a flags/id/fsid update */
 745
 746                 exp_fsid_unhash(exp);
 747                 exp->ex_flags    = nxp->ex_flags;
 748                 exp->ex_anon_uid = nxp->ex_anon_uid;
 749                 exp->ex_anon_gid = nxp->ex_anon_gid;
 750                 exp->ex_fsid     = nxp->ex_dev;
 751
 752                 err = exp_fsid_hash(clp, exp);
 753                 goto finish;
 754         }
 755
 756         err = check_export(nd.dentry->d_inode, nxp->ex_flags);
 757         if (err) goto finish;
 758
 759         err = -ENOMEM;
 760
 761         dprintk("nfsd: creating export entry %p for client %p\n", exp, clp);
 762
 763         new.h.expiry_time = NEVER;
 764         new.h.flags = 0;
 765         new.ex_client = clp;
 766         new.ex_mnt = nd.mnt;
 767         new.ex_dentry = nd.dentry;
 768         new.ex_flags = nxp->ex_flags;
 769         new.ex_anon_uid = nxp->ex_anon_uid;
 770         new.ex_anon_gid = nxp->ex_anon_gid;
 771         new.ex_fsid = nxp->ex_dev;
 772
 773         exp = svc_export_lookup(&new, 1);
 774
 775         if (exp == NULL)
 776                 goto finish;
 777
 778         err = 0;
 779
 780         if (exp_hash(clp, exp) ||
 781             exp_fsid_hash(clp, exp)) {
 782                 /* failed to create at least one index */
 783                 exp_do_unexport(exp);
 784                 cache_flush();
 785                 err = -ENOMEM;
 786         }
 787
 788 finish:
 789         if (exp)
 790                 exp_put(exp);
 791         if (fsid_key && !IS_ERR(fsid_key))
 792                 expkey_put(&fsid_key->h, &svc_expkey_cache);
 793         if (clp)
 794                 auth_domain_put(clp);
 795         path_release(&nd);
 796 out_unlock:
 797         exp_writeunlock();
 798 out:
 799         return err;
 800 }
 801
 802 /*
 803  * Unexport a file system. The export entry has already
 804  * been removed from the client's list of exported fs's.
 805  */
 806 static void
 807 exp_do_unexport(svc_export *unexp)
 808 {
 809         unexp->h.expiry_time = get_seconds()-1;
 810         svc_export_cache.nextcheck = get_seconds();
 811         exp_unhash(unexp);
 812         exp_fsid_unhash(unexp);
 813 }
 814
 815
 816 /*
 817  * unexport syscall.
 818  */
 819 int
 820 exp_unexport(struct nfsctl_export *nxp)
 821 {
 822         struct auth_domain *dom;
 823         svc_export *exp;
 824         struct nameidata nd;
 825         int             err;
 826
 827         /* Consistency check */
 828         if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
 829             !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
 830                 return -EINVAL;
 831
 832         exp_writelock();
 833
 834         err = -EINVAL;
 835         dom = auth_domain_find(nxp->ex_client);
 836         if (!dom) {
 837                 dprintk("nfsd: unexport couldn't find %s\n", nxp->ex_client);
 838                 goto out_unlock;
 839         }
 840
 841         err = path_lookup(nxp->ex_path, 0, &nd);
 842         if (err)
 843                 goto out_domain;
 844
 845         err = -EINVAL;
 846         exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
 847         path_release(&nd);
 848         if (!exp)
 849                 goto out_domain;
 850
 851         exp_do_unexport(exp);
 852         exp_put(exp);
 853         err = 0;
 854
 855 out_domain:
 856         auth_domain_put(dom);
 857         cache_flush();
 858 out_unlock:
 859         exp_writeunlock();
 860         return err;
 861 }
 862
 863 /*
 864  * Obtain the root fh on behalf of a client.
 865  * This could be done in user space, but I feel that it adds some safety
 866  * since its harder to fool a kernel module than a user space program.
 867  */
 868 int
 869 exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
 870 {
 871         struct svc_export       *exp;
 872         struct nameidata        nd;
 873         struct inode            *inode;
 874         struct svc_fh           fh;
 875         int                     err;
 876
 877         err = -EPERM;
 878         /* NB: we probably ought to check that it's NUL-terminated */
 879         if (path_lookup(path, 0, &nd)) {
 880                 printk("nfsd: exp_rootfh path not found %s", path);
 881                 return err;
 882         }
 883         inode = nd.dentry->d_inode;
 884
 885         dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
 886                  path, nd.dentry, clp->name,
 887                  inode->i_sb->s_id, inode->i_ino);
 888         exp = exp_parent(clp, nd.mnt, nd.dentry, NULL);
 889         if (!exp) {
 890                 dprintk("nfsd: exp_rootfh export not found.\n");
 891                 goto out;
 892         }
 893
 894         /*
 895          * fh must be initialized before calling fh_compose
 896          */
 897         fh_init(&fh, maxsize);
 898         if (fh_compose(&fh, exp, nd.dentry, NULL))
 899                 err = -EINVAL;
 900         else
 901                 err = 0;
 902         memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh));
 903         fh_put(&fh);
 904         exp_put(exp);
 905 out:
 906         path_release(&nd);
 907         return err;
 908 }
 909
 910 struct svc_export *
 911 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
 912          struct cache_req *reqp)
 913 {
 914         struct svc_export *exp;
 915         struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
 916         if (!ek || IS_ERR(ek))
 917                 return ERR_PTR(PTR_ERR(ek));
 918
 919         exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
 920         expkey_put(&ek->h, &svc_expkey_cache);
 921
 922         if (!exp || IS_ERR(exp))
 923                 return ERR_PTR(PTR_ERR(exp));
 924         return exp;
 925 }
 926
 927
 928 /*
 929  * Called when we need the filehandle for the root of the pseudofs,
 930  * for a given NFSv4 client.   The root is defined to be the
 931  * export point with fsid==0
 932  */
 933 int
 934 exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
 935                struct cache_req *creq)
 936 {
 937         struct svc_expkey *fsid_key;
 938         struct svc_export *exp;
 939         int rv;
 940         u32 fsidv[2];
 941
 942         mk_fsid_v1(fsidv, 0);
 943
 944         fsid_key = exp_find_key(clp, 1, fsidv, creq);
 945         if (IS_ERR(fsid_key) && PTR_ERR(fsid_key) == -EAGAIN)
 946                 return nfserr_dropit;
 947         if (!fsid_key || IS_ERR(fsid_key))
 948                 return nfserr_perm;
 949
 950         exp = exp_get_by_name(clp, fsid_key->ek_mnt, fsid_key->ek_dentry, creq);
 951         if (exp == NULL)
 952                 rv = nfserr_perm;
 953         else if (IS_ERR(exp))
 954                 rv = nfserrno(PTR_ERR(exp));
 955         else
 956                 rv = fh_compose(fhp, exp,
 957                                 fsid_key->ek_dentry, NULL);
 958         expkey_put(&fsid_key->h, &svc_expkey_cache);
 959         return rv;
 960 }
 961
 962 /* Iterator */
 963
 964 static void *e_start(struct seq_file *m, loff_t *pos)
 965 {
 966         loff_t n = *pos;
 967         unsigned hash, export;
 968         struct cache_head *ch;
 969
 970         exp_readlock();
 971         read_lock(&svc_export_cache.hash_lock);
 972         if (!n--)
 973                 return (void *)1;
 974         hash = n >> 32;
 975         export = n & ((1LL<<32) - 1);
 976
 977
 978         for (ch=export_table[hash]; ch; ch=ch->next)
 979                 if (!export--)
 980                         return ch;
 981         n &= ~((1LL<<32) - 1);
 982         do {
 983                 hash++;
 984                 n += 1LL<<32;
 985         } while(hash < EXPORT_HASHMAX && export_table[hash]==NULL);
 986         if (hash >= EXPORT_HASHMAX)
 987                 return NULL;
 988         *pos = n+1;
 989         return export_table[hash];
 990 }
 991
 992 static void *e_next(struct seq_file *m, void *p, loff_t *pos)
 993 {
 994         struct cache_head *ch = p;
 995         int hash = (*pos >> 32);
 996
 997         if (p == (void *)1)
 998                 hash = 0;
 999         else if (ch->next == NULL) {
1000                 hash++;
1001                 *pos += 1LL<<32;
1002         } else {
1003                 ++*pos;
1004                 return ch->next;
1005         }
1006         *pos &= ~((1LL<<32) - 1);
1007         while (hash < EXPORT_HASHMAX && export_table[hash] == NULL) {
1008                 hash++;
1009                 *pos += 1LL<<32;
1010         }
1011         if (hash >= EXPORT_HASHMAX)
1012                 return NULL;
1013         ++*pos;
1014         return export_table[hash];
1015 }
1016
1017 static void e_stop(struct seq_file *m, void *p)
1018 {
1019         read_unlock(&svc_export_cache.hash_lock);
1020         exp_readunlock();
1021 }
1022
1023 static struct flags {
1024         int flag;
1025         char *name[2];
1026 } expflags[] = {
1027         { NFSEXP_READONLY, {"ro", "rw"}},
1028         { NFSEXP_INSECURE_PORT, {"insecure", ""}},
1029         { NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}},
1030         { NFSEXP_ALLSQUASH, {"all_squash", ""}},
1031         { NFSEXP_ASYNC, {"async", "sync"}},
1032         { NFSEXP_GATHERED_WRITES, {"wdelay", "no_wdelay"}},
1033         { NFSEXP_NOHIDE, {"nohide", ""}},
1034         { NFSEXP_CROSSMOUNT, {"crossmnt", ""}},
1035         { NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}},
1036         { NFSEXP_NOAUTHNLM, {"insecure_locks", ""}},
1037 #ifdef MSNFS
1038         { NFSEXP_MSNFS, {"msnfs", ""}},
1039 #endif
1040         { 0, {"", ""}}
1041 };
1042
1043 static void exp_flags(struct seq_file *m, int flag, int fsid, uid_t anonu, uid_t anong)
1044 {
1045         int first = 0;
1046         struct flags *flg;
1047
1048         for (flg = expflags; flg->flag; flg++) {
1049                 int state = (flg->flag & flag)?0:1;
1050                 if (*flg->name[state])
1051                         seq_printf(m, "%s%s", first++?",":"", flg->name[state]);
1052         }
1053         if (flag & NFSEXP_FSID)
1054                 seq_printf(m, "%sfsid=%d", first++?",":"", fsid);
1055         if (anonu != (uid_t)-2 && anonu != (0x10000-2))
1056                 seq_printf(m, "%sanonuid=%d", first++?",":"", anonu);
1057         if (anong != (gid_t)-2 && anong != (0x10000-2))
1058                 seq_printf(m, "%sanongid=%d", first++?",":"", anong);
1059 }
1060
1061 static int e_show(struct seq_file *m, void *p)
1062 {
1063         struct cache_head *cp = p;
1064         struct svc_export *exp = container_of(cp, struct svc_export, h);
1065         svc_client *clp;
1066
1067         if (p == (void *)1) {
1068                 seq_puts(m, "# Version 1.1\n");
1069                 seq_puts(m, "# Path Client(Flags) # IPs\n");
1070                 return 0;
1071         }
1072
1073         clp = exp->ex_client;
1074         cache_get(&exp->h);
1075         if (cache_check(&svc_export_cache, &exp->h, NULL))
1076                 return 0;
1077         if (cache_put(&exp->h, &svc_export_cache)) BUG();
1078         return svc_export_show(m, &svc_export_cache, cp);
1079 }
1080
1081 struct seq_operations nfs_exports_op = {
1082         .start  = e_start,
1083         .next   = e_next,
1084         .stop   = e_stop,
1085         .show   = e_show,
1086 };
1087
1088 /*
1089  * Add or modify a client.
1090  * Change requests may involve the list of host addresses. The list of
1091  * exports and possibly existing uid maps are left untouched.
1092  */
1093 int
1094 exp_addclient(struct nfsctl_client *ncp)
1095 {
1096         struct auth_domain      *dom;
1097         int                     i, err;
1098
1099         /* First, consistency check. */
1100         err = -EINVAL;
1101         if (! exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1102                 goto out;
1103         if (ncp->cl_naddr > NFSCLNT_ADDRMAX)
1104                 goto out;
1105
1106         /* Lock the hashtable */
1107         exp_writelock();
1108
1109         dom = unix_domain_find(ncp->cl_ident);
1110
1111         err = -ENOMEM;
1112         if (!dom)
1113                 goto out_unlock;
1114
1115         /* Insert client into hashtable. */
1116         for (i = 0; i < ncp->cl_naddr; i++)
1117                 auth_unix_add_addr(ncp->cl_addrlist[i], dom);
1118
1119         auth_unix_forget_old(dom);
1120         auth_domain_put(dom);
1121
1122         err = 0;
1123
1124 out_unlock:
1125         exp_writeunlock();
1126 out:
1127         return err;
1128 }
1129
1130 /*
1131  * Delete a client given an identifier.
1132  */
1133 int
1134 exp_delclient(struct nfsctl_client *ncp)
1135 {
1136         int             err;
1137         struct auth_domain *dom;
1138
1139         err = -EINVAL;
1140         if (!exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1141                 goto out;
1142
1143         /* Lock the hashtable */
1144         exp_writelock();
1145
1146         dom = auth_domain_find(ncp->cl_ident);
1147         /* just make sure that no addresses work
1148          * and that it will expire soon
1149          */
1150         if (dom) {
1151                 err = auth_unix_forget_old(dom);
1152                 auth_domain_put(dom);
1153         }
1154
1155         exp_writeunlock();
1156 out:
1157         return err;
1158 }
1159
1160 /*
1161  * Verify that string is non-empty and does not exceed max length.
1162  */
1163 static int
1164 exp_verify_string(char *cp, int max)
1165 {
1166         int     i;
1167
1168         for (i = 0; i < max; i++)
1169                 if (!cp[i])
1170                         return i;
1171         cp[i] = 0;
1172         printk(KERN_NOTICE "nfsd: couldn't validate string %s\n", cp);
1173         return 0;
1174 }
1175
1176 /*
1177  * Initialize the exports module.
1178  */
1179 void
1180 nfsd_export_init(void)
1181 {
1182         dprintk("nfsd: initializing export module.\n");
1183
1184         cache_register(&svc_export_cache);
1185         cache_register(&svc_expkey_cache);
1186
1187 }
1188
1189 /*
1190  * Flush exports table - called when last nfsd thread is killed
1191  */
1192 void
1193 nfsd_export_flush(void)
1194 {
1195         exp_writelock();
1196         cache_purge(&svc_expkey_cache);
1197         cache_purge(&svc_export_cache);
1198         exp_writeunlock();
1199 }
1200
1201 /*
1202  * Shutdown the exports module.
1203  */
1204 void
1205 nfsd_export_shutdown(void)
1206 {
1207
1208         dprintk("nfsd: shutting down export module.\n");
1209
1210         exp_writelock();
1211
1212         if (cache_unregister(&svc_expkey_cache))
1213                 printk(KERN_ERR "nfsd: failed to unregister expkey cache\n");
1214         if (cache_unregister(&svc_export_cache))
1215                 printk(KERN_ERR "nfsd: failed to unregister export cache\n");
1216         svcauth_unix_purge();
1217
1218         exp_writeunlock();
1219         dprintk("nfsd: export shutdown complete.\n");
1220 }