SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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, svc_expkey)
 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 void svc_export_put(struct cache_head *item, struct cache_detail *cd)
 262 {
 263         if (cache_put(item, cd)) {
 264                 struct svc_export *exp = container_of(item, struct svc_export, h);
 265                 dput(exp->ex_dentry);
 266                 mntput(exp->ex_mnt);
 267                 auth_domain_put(exp->ex_client);
 268                 kfree(exp);
 269         }
 270 }
 271
 272 static void svc_export_request(struct cache_detail *cd,
 273                                struct cache_head *h,
 274                                char **bpp, int *blen)
 275 {
 276         /*  client path */
 277         struct svc_export *exp = container_of(h, struct svc_export, h);
 278         char *pth;
 279
 280         qword_add(bpp, blen, exp->ex_client->name);
 281         pth = d_path(exp->ex_dentry, exp->ex_mnt, *bpp, *blen);
 282         if (IS_ERR(pth)) {
 283                 /* is this correct? */
 284                 (*bpp)[0] = '\n';
 285                 return;
 286         }
 287         qword_add(bpp, blen, pth);
 288         (*bpp)[-1] = '\n';
 289 }
 290
 291 struct svc_export *svc_export_update(struct svc_export *new, struct svc_export *old);
 292 static struct svc_export *svc_export_lookup(struct svc_export *);
 293
 294 static int check_export(struct inode *inode, int flags)
 295 {
 296
 297         /* We currently export only dirs and regular files.
 298          * This is what umountd does.
 299          */
 300         if (!S_ISDIR(inode->i_mode) &&
 301             !S_ISREG(inode->i_mode))
 302                 return -ENOTDIR;
 303
 304         /* There are two requirements on a filesystem to be exportable.
 305          * 1:  We must be able to identify the filesystem from a number.
 306          *       either a device number (so FS_REQUIRES_DEV needed)
 307          *       or an FSID number (so NFSEXP_FSID needed).
 308          * 2:  We must be able to find an inode from a filehandle.
 309          *       This means that s_export_op must be set.
 310          */
 311         if (!(inode->i_sb->s_type->fs_flags & FS_REQUIRES_DEV) &&
 312             !(flags & NFSEXP_FSID)) {
 313                 dprintk("exp_export: export of non-dev fs without fsid");
 314                 return -EINVAL;
 315         }
 316         if (!inode->i_sb->s_export_op) {
 317                 dprintk("exp_export: export of invalid fs type.\n");
 318                 return -EINVAL;
 319         }
 320
 321         /* Ok, we can export it */;
 322         if (!inode->i_sb->s_export_op->find_exported_dentry)
 323                 inode->i_sb->s_export_op->find_exported_dentry =
 324                         find_exported_dentry;
 325         return 0;
 326
 327 }
 328
 329 static int svc_export_parse(struct cache_detail *cd, char *mesg, int mlen)
 330 {
 331         /* client path expiry [flags anonuid anongid fsid] */
 332         char *buf;
 333         int len;
 334         int err;
 335         struct auth_domain *dom = NULL;
 336         struct nameidata nd;
 337         struct svc_export exp, *expp;
 338         int an_int;
 339
 340         nd.dentry = NULL;
 341
 342         if (mesg[mlen-1] != '\n')
 343                 return -EINVAL;
 344         mesg[mlen-1] = 0;
 345
 346         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 347         err = -ENOMEM;
 348         if (!buf) goto out;
 349
 350         /* client */
 351         len = qword_get(&mesg, buf, PAGE_SIZE);
 352         err = -EINVAL;
 353         if (len <= 0) goto out;
 354
 355         err = -ENOENT;
 356         dom = auth_domain_find(buf);
 357         if (!dom)
 358                 goto out;
 359
 360         /* path */
 361         err = -EINVAL;
 362         if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
 363                 goto out;
 364         err = path_lookup(buf, 0, &nd);
 365         if (err) goto out;
 366
 367         exp.h.flags = 0;
 368         exp.ex_client = dom;
 369         exp.ex_mnt = nd.mnt;
 370         exp.ex_dentry = nd.dentry;
 371
 372         /* expiry */
 373         err = -EINVAL;
 374         exp.h.expiry_time = get_expiry(&mesg);
 375         if (exp.h.expiry_time == 0)
 376                 goto out;
 377
 378         /* flags */
 379         err = get_int(&mesg, &an_int);
 380         if (err == -ENOENT)
 381                 set_bit(CACHE_NEGATIVE, &exp.h.flags);
 382         else {
 383                 if (err || an_int < 0) goto out;
 384                 exp.ex_flags= an_int;
 385
 386                 /* anon uid */
 387                 err = get_int(&mesg, &an_int);
 388                 if (err) goto out;
 389                 exp.ex_anon_uid= an_int;
 390
 391                 /* anon gid */
 392                 err = get_int(&mesg, &an_int);
 393                 if (err) goto out;
 394                 exp.ex_anon_gid= an_int;
 395
 396                 /* fsid */
 397                 err = get_int(&mesg, &an_int);
 398                 if (err) goto out;
 399                 exp.ex_fsid = an_int;
 400
 401                 err = check_export(nd.dentry->d_inode, exp.ex_flags);
 402                 if (err) goto out;
 403         }
 404
 405         expp = svc_export_lookup(&exp);
 406         if (expp)
 407                 expp = svc_export_update(&exp, expp);
 408         else
 409                 err = -ENOMEM;
 410         cache_flush();
 411         if (expp == NULL)
 412                 err = -ENOMEM;
 413         else
 414                 exp_put(expp);
 415  out:
 416         if (nd.dentry)
 417                 path_release(&nd);
 418         if (dom)
 419                 auth_domain_put(dom);
 420         kfree(buf);
 421         return err;
 422 }
 423
 424 static void exp_flags(struct seq_file *m, int flag, int fsid, uid_t anonu, uid_t anong);
 425
 426 static int svc_export_show(struct seq_file *m,
 427                            struct cache_detail *cd,
 428                            struct cache_head *h)
 429 {
 430         struct svc_export *exp ;
 431
 432         if (h ==NULL) {
 433                 seq_puts(m, "#path domain(flags)\n");
 434                 return 0;
 435         }
 436         exp = container_of(h, struct svc_export, h);
 437         seq_path(m, exp->ex_mnt, exp->ex_dentry, " \t\n\\");
 438         seq_putc(m, '\t');
 439         seq_escape(m, exp->ex_client->name, " \t\n\\");
 440         seq_putc(m, '(');
 441         if (test_bit(CACHE_VALID, &h->flags) &&
 442             !test_bit(CACHE_NEGATIVE, &h->flags))
 443                 exp_flags(m, exp->ex_flags, exp->ex_fsid,
 444                           exp->ex_anon_uid, exp->ex_anon_gid);
 445         seq_puts(m, ")\n");
 446         return 0;
 447 }
 448 static int svc_export_match(struct cache_head *a, struct cache_head *b)
 449 {
 450         struct svc_export *orig = container_of(a, struct svc_export, h);
 451         struct svc_export *new = container_of(b, struct svc_export, h);
 452         return orig->ex_client == new->ex_client &&
 453                 orig->ex_dentry == new->ex_dentry &&
 454                 orig->ex_mnt == new->ex_mnt;
 455 }
 456
 457 static void svc_export_init(struct cache_head *cnew, struct cache_head *citem)
 458 {
 459         struct svc_export *new = container_of(cnew, struct svc_export, h);
 460         struct svc_export *item = container_of(citem, struct svc_export, h);
 461
 462         kref_get(&item->ex_client->ref);
 463         new->ex_client = item->ex_client;
 464         new->ex_dentry = dget(item->ex_dentry);
 465         new->ex_mnt = mntget(item->ex_mnt);
 466 }
 467
 468 static void export_update(struct cache_head *cnew, struct cache_head *citem)
 469 {
 470         struct svc_export *new = container_of(cnew, struct svc_export, h);
 471         struct svc_export *item = container_of(citem, struct svc_export, h);
 472
 473         new->ex_flags = item->ex_flags;
 474         new->ex_anon_uid = item->ex_anon_uid;
 475         new->ex_anon_gid = item->ex_anon_gid;
 476         new->ex_fsid = item->ex_fsid;
 477 }
 478
 479 static struct cache_head *svc_export_alloc(void)
 480 {
 481         struct svc_export *i = kmalloc(sizeof(*i), GFP_KERNEL);
 482         if (i)
 483                 return &i->h;
 484         else
 485                 return NULL;
 486 }
 487
 488 struct cache_detail svc_export_cache = {
 489         .owner          = THIS_MODULE,
 490         .hash_size      = EXPORT_HASHMAX,
 491         .hash_table     = export_table,
 492         .name           = "nfsd.export",
 493         .cache_put      = svc_export_put,
 494         .cache_request  = svc_export_request,
 495         .cache_parse    = svc_export_parse,
 496         .cache_show     = svc_export_show,
 497         .match          = svc_export_match,
 498         .init           = svc_export_init,
 499         .update         = export_update,
 500         .alloc          = svc_export_alloc,
 501 };
 502
 503 static struct svc_export *
 504 svc_export_lookup(struct svc_export *exp)
 505 {
 506         struct cache_head *ch;
 507         int hash;
 508         hash = hash_ptr(exp->ex_client, EXPORT_HASHBITS);
 509         hash ^= hash_ptr(exp->ex_dentry, EXPORT_HASHBITS);
 510         hash ^= hash_ptr(exp->ex_mnt, EXPORT_HASHBITS);
 511
 512         ch = sunrpc_cache_lookup(&svc_export_cache, &exp->h,
 513                                  hash);
 514         if (ch)
 515                 return container_of(ch, struct svc_export, h);
 516         else
 517                 return NULL;
 518 }
 519
 520 struct svc_export *
 521 svc_export_update(struct svc_export *new, struct svc_export *old)
 522 {
 523         struct cache_head *ch;
 524         int hash;
 525         hash = hash_ptr(old->ex_client, EXPORT_HASHBITS);
 526         hash ^= hash_ptr(old->ex_dentry, EXPORT_HASHBITS);
 527         hash ^= hash_ptr(old->ex_mnt, EXPORT_HASHBITS);
 528
 529         ch = sunrpc_cache_update(&svc_export_cache, &new->h,
 530                                  &old->h,
 531                                  hash);
 532         if (ch)
 533                 return container_of(ch, struct svc_export, h);
 534         else
 535                 return NULL;
 536 }
 537
 538
 539 struct svc_expkey *
 540 exp_find_key(svc_client *clp, int fsid_type, u32 *fsidv, struct cache_req *reqp)
 541 {
 542         struct svc_expkey key, *ek;
 543         int err;
 544
 545         if (!clp)
 546                 return NULL;
 547
 548         key.ek_client = clp;
 549         key.ek_fsidtype = fsid_type;
 550         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 551
 552         ek = svc_expkey_lookup(&key, 0);
 553         if (ek != NULL)
 554                 if ((err = cache_check(&svc_expkey_cache, &ek->h, reqp)))
 555                         ek = ERR_PTR(err);
 556         return ek;
 557 }
 558
 559 static int exp_set_key(svc_client *clp, int fsid_type, u32 *fsidv,
 560                        struct svc_export *exp)
 561 {
 562         struct svc_expkey key, *ek;
 563
 564         key.ek_client = clp;
 565         key.ek_fsidtype = fsid_type;
 566         memcpy(key.ek_fsid, fsidv, key_len(fsid_type));
 567         key.ek_mnt = exp->ex_mnt;
 568         key.ek_dentry = exp->ex_dentry;
 569         key.h.expiry_time = NEVER;
 570         key.h.flags = 0;
 571
 572         ek = svc_expkey_lookup(&key, 1);
 573         if (ek) {
 574                 expkey_put(&ek->h, &svc_expkey_cache);
 575                 return 0;
 576         }
 577         return -ENOMEM;
 578 }
 579
 580 /*
 581  * Find the client's export entry matching xdev/xino.
 582  */
 583 static inline struct svc_expkey *
 584 exp_get_key(svc_client *clp, dev_t dev, ino_t ino)
 585 {
 586         u32 fsidv[3];
 587
 588         if (old_valid_dev(dev)) {
 589                 mk_fsid_v0(fsidv, dev, ino);
 590                 return exp_find_key(clp, 0, fsidv, NULL);
 591         }
 592         mk_fsid_v3(fsidv, dev, ino);
 593         return exp_find_key(clp, 3, fsidv, NULL);
 594 }
 595
 596 /*
 597  * Find the client's export entry matching fsid
 598  */
 599 static inline struct svc_expkey *
 600 exp_get_fsid_key(svc_client *clp, int fsid)
 601 {
 602         u32 fsidv[2];
 603
 604         mk_fsid_v1(fsidv, fsid);
 605
 606         return exp_find_key(clp, 1, fsidv, NULL);
 607 }
 608
 609 svc_export *
 610 exp_get_by_name(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
 611                 struct cache_req *reqp)
 612 {
 613         struct svc_export *exp, key;
 614
 615         if (!clp)
 616                 return NULL;
 617
 618         key.ex_client = clp;
 619         key.ex_mnt = mnt;
 620         key.ex_dentry = dentry;
 621
 622         exp = svc_export_lookup(&key);
 623         if (exp != NULL)
 624                 switch (cache_check(&svc_export_cache, &exp->h, reqp)) {
 625                 case 0: break;
 626                 case -EAGAIN:
 627                         exp = ERR_PTR(-EAGAIN);
 628                         break;
 629                 default:
 630                         exp = NULL;
 631                 }
 632
 633         return exp;
 634 }
 635
 636 /*
 637  * Find the export entry for a given dentry.
 638  */
 639 struct svc_export *
 640 exp_parent(svc_client *clp, struct vfsmount *mnt, struct dentry *dentry,
 641            struct cache_req *reqp)
 642 {
 643         svc_export *exp;
 644
 645         dget(dentry);
 646         exp = exp_get_by_name(clp, mnt, dentry, reqp);
 647
 648         while (exp == NULL && !IS_ROOT(dentry)) {
 649                 struct dentry *parent;
 650
 651                 parent = dget_parent(dentry);
 652                 dput(dentry);
 653                 dentry = parent;
 654                 exp = exp_get_by_name(clp, mnt, dentry, reqp);
 655         }
 656         dput(dentry);
 657         return exp;
 658 }
 659
 660 /*
 661  * Hashtable locking. Write locks are placed only by user processes
 662  * wanting to modify export information.
 663  * Write locking only done in this file.  Read locking
 664  * needed externally.
 665  */
 666
 667 static DECLARE_RWSEM(hash_sem);
 668
 669 void
 670 exp_readlock(void)
 671 {
 672         down_read(&hash_sem);
 673 }
 674
 675 static inline void
 676 exp_writelock(void)
 677 {
 678         down_write(&hash_sem);
 679 }
 680
 681 void
 682 exp_readunlock(void)
 683 {
 684         up_read(&hash_sem);
 685 }
 686
 687 static inline void
 688 exp_writeunlock(void)
 689 {
 690         up_write(&hash_sem);
 691 }
 692
 693 static void exp_fsid_unhash(struct svc_export *exp)
 694 {
 695         struct svc_expkey *ek;
 696
 697         if ((exp->ex_flags & NFSEXP_FSID) == 0)
 698                 return;
 699
 700         ek = exp_get_fsid_key(exp->ex_client, exp->ex_fsid);
 701         if (ek && !IS_ERR(ek)) {
 702                 ek->h.expiry_time = get_seconds()-1;
 703                 expkey_put(&ek->h, &svc_expkey_cache);
 704         }
 705         svc_expkey_cache.nextcheck = get_seconds();
 706 }
 707
 708 static int exp_fsid_hash(svc_client *clp, struct svc_export *exp)
 709 {
 710         u32 fsid[2];
 711
 712         if ((exp->ex_flags & NFSEXP_FSID) == 0)
 713                 return 0;
 714
 715         mk_fsid_v1(fsid, exp->ex_fsid);
 716         return exp_set_key(clp, 1, fsid, exp);
 717 }
 718
 719 static int exp_hash(struct auth_domain *clp, struct svc_export *exp)
 720 {
 721         u32 fsid[2];
 722         struct inode *inode = exp->ex_dentry->d_inode;
 723         dev_t dev = inode->i_sb->s_dev;
 724
 725         if (old_valid_dev(dev)) {
 726                 mk_fsid_v0(fsid, dev, inode->i_ino);
 727                 return exp_set_key(clp, 0, fsid, exp);
 728         }
 729         mk_fsid_v3(fsid, dev, inode->i_ino);
 730         return exp_set_key(clp, 3, fsid, exp);
 731 }
 732
 733 static void exp_unhash(struct svc_export *exp)
 734 {
 735         struct svc_expkey *ek;
 736         struct inode *inode = exp->ex_dentry->d_inode;
 737
 738         ek = exp_get_key(exp->ex_client, inode->i_sb->s_dev, inode->i_ino);
 739         if (ek && !IS_ERR(ek)) {
 740                 ek->h.expiry_time = get_seconds()-1;
 741                 expkey_put(&ek->h, &svc_expkey_cache);
 742         }
 743         svc_expkey_cache.nextcheck = get_seconds();
 744 }
 745
 746 /*
 747  * Export a file system.
 748  */
 749 int
 750 exp_export(struct nfsctl_export *nxp)
 751 {
 752         svc_client      *clp;
 753         struct svc_export       *exp = NULL;
 754         struct svc_export       new;
 755         struct svc_expkey       *fsid_key = NULL;
 756         struct nameidata nd;
 757         int             err;
 758
 759         /* Consistency check */
 760         err = -EINVAL;
 761         if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
 762             !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
 763                 goto out;
 764
 765         dprintk("exp_export called for %s:%s (%x/%ld fl %x).\n",
 766                         nxp->ex_client, nxp->ex_path,
 767                         (unsigned)nxp->ex_dev, (long)nxp->ex_ino,
 768                         nxp->ex_flags);
 769
 770         /* Try to lock the export table for update */
 771         exp_writelock();
 772
 773         /* Look up client info */
 774         if (!(clp = auth_domain_find(nxp->ex_client)))
 775                 goto out_unlock;
 776
 777
 778         /* Look up the dentry */
 779         err = path_lookup(nxp->ex_path, 0, &nd);
 780         if (err)
 781                 goto out_unlock;
 782         err = -EINVAL;
 783
 784         exp = exp_get_by_name(clp, nd.mnt, nd.dentry, NULL);
 785
 786         /* must make sure there won't be an ex_fsid clash */
 787         if ((nxp->ex_flags & NFSEXP_FSID) &&
 788             (fsid_key = exp_get_fsid_key(clp, nxp->ex_dev)) &&
 789             !IS_ERR(fsid_key) &&
 790             fsid_key->ek_mnt &&
 791             (fsid_key->ek_mnt != nd.mnt || fsid_key->ek_dentry != nd.dentry) )
 792                 goto finish;
 793
 794         if (exp) {
 795                 /* just a flags/id/fsid update */
 796
 797                 exp_fsid_unhash(exp);
 798                 exp->ex_flags    = nxp->ex_flags;
 799                 exp->ex_anon_uid = nxp->ex_anon_uid;
 800                 exp->ex_anon_gid = nxp->ex_anon_gid;
 801                 exp->ex_fsid     = nxp->ex_dev;
 802
 803                 err = exp_fsid_hash(clp, exp);
 804                 goto finish;
 805         }
 806
 807         err = check_export(nd.dentry->d_inode, nxp->ex_flags);
 808         if (err) goto finish;
 809
 810         err = -ENOMEM;
 811
 812         dprintk("nfsd: creating export entry %p for client %p\n", exp, clp);
 813
 814         new.h.expiry_time = NEVER;
 815         new.h.flags = 0;
 816         new.ex_client = clp;
 817         new.ex_mnt = nd.mnt;
 818         new.ex_dentry = nd.dentry;
 819         new.ex_flags = nxp->ex_flags;
 820         new.ex_anon_uid = nxp->ex_anon_uid;
 821         new.ex_anon_gid = nxp->ex_anon_gid;
 822         new.ex_fsid = nxp->ex_dev;
 823
 824         exp = svc_export_lookup(&new);
 825         if (exp)
 826                 exp = svc_export_update(&new, exp);
 827
 828         if (!exp)
 829                 goto finish;
 830
 831         if (exp_hash(clp, exp) ||
 832             exp_fsid_hash(clp, exp)) {
 833                 /* failed to create at least one index */
 834                 exp_do_unexport(exp);
 835                 cache_flush();
 836                 err = -ENOMEM;
 837         }
 838
 839 finish:
 840         if (exp)
 841                 exp_put(exp);
 842         if (fsid_key && !IS_ERR(fsid_key))
 843                 expkey_put(&fsid_key->h, &svc_expkey_cache);
 844         if (clp)
 845                 auth_domain_put(clp);
 846         path_release(&nd);
 847 out_unlock:
 848         exp_writeunlock();
 849 out:
 850         return err;
 851 }
 852
 853 /*
 854  * Unexport a file system. The export entry has already
 855  * been removed from the client's list of exported fs's.
 856  */
 857 static void
 858 exp_do_unexport(svc_export *unexp)
 859 {
 860         unexp->h.expiry_time = get_seconds()-1;
 861         svc_export_cache.nextcheck = get_seconds();
 862         exp_unhash(unexp);
 863         exp_fsid_unhash(unexp);
 864 }
 865
 866
 867 /*
 868  * unexport syscall.
 869  */
 870 int
 871 exp_unexport(struct nfsctl_export *nxp)
 872 {
 873         struct auth_domain *dom;
 874         svc_export *exp;
 875         struct nameidata nd;
 876         int             err;
 877
 878         /* Consistency check */
 879         if (!exp_verify_string(nxp->ex_path, NFS_MAXPATHLEN) ||
 880             !exp_verify_string(nxp->ex_client, NFSCLNT_IDMAX))
 881                 return -EINVAL;
 882
 883         exp_writelock();
 884
 885         err = -EINVAL;
 886         dom = auth_domain_find(nxp->ex_client);
 887         if (!dom) {
 888                 dprintk("nfsd: unexport couldn't find %s\n", nxp->ex_client);
 889                 goto out_unlock;
 890         }
 891
 892         err = path_lookup(nxp->ex_path, 0, &nd);
 893         if (err)
 894                 goto out_domain;
 895
 896         err = -EINVAL;
 897         exp = exp_get_by_name(dom, nd.mnt, nd.dentry, NULL);
 898         path_release(&nd);
 899         if (!exp)
 900                 goto out_domain;
 901
 902         exp_do_unexport(exp);
 903         exp_put(exp);
 904         err = 0;
 905
 906 out_domain:
 907         auth_domain_put(dom);
 908         cache_flush();
 909 out_unlock:
 910         exp_writeunlock();
 911         return err;
 912 }
 913
 914 /*
 915  * Obtain the root fh on behalf of a client.
 916  * This could be done in user space, but I feel that it adds some safety
 917  * since its harder to fool a kernel module than a user space program.
 918  */
 919 int
 920 exp_rootfh(svc_client *clp, char *path, struct knfsd_fh *f, int maxsize)
 921 {
 922         struct svc_export       *exp;
 923         struct nameidata        nd;
 924         struct inode            *inode;
 925         struct svc_fh           fh;
 926         int                     err;
 927
 928         err = -EPERM;
 929         /* NB: we probably ought to check that it's NUL-terminated */
 930         if (path_lookup(path, 0, &nd)) {
 931                 printk("nfsd: exp_rootfh path not found %s", path);
 932                 return err;
 933         }
 934         inode = nd.dentry->d_inode;
 935
 936         dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
 937                  path, nd.dentry, clp->name,
 938                  inode->i_sb->s_id, inode->i_ino);
 939         exp = exp_parent(clp, nd.mnt, nd.dentry, NULL);
 940         if (!exp) {
 941                 dprintk("nfsd: exp_rootfh export not found.\n");
 942                 goto out;
 943         }
 944
 945         /*
 946          * fh must be initialized before calling fh_compose
 947          */
 948         fh_init(&fh, maxsize);
 949         if (fh_compose(&fh, exp, nd.dentry, NULL))
 950                 err = -EINVAL;
 951         else
 952                 err = 0;
 953         memcpy(f, &fh.fh_handle, sizeof(struct knfsd_fh));
 954         fh_put(&fh);
 955         exp_put(exp);
 956 out:
 957         path_release(&nd);
 958         return err;
 959 }
 960
 961 struct svc_export *
 962 exp_find(struct auth_domain *clp, int fsid_type, u32 *fsidv,
 963          struct cache_req *reqp)
 964 {
 965         struct svc_export *exp;
 966         struct svc_expkey *ek = exp_find_key(clp, fsid_type, fsidv, reqp);
 967         if (!ek || IS_ERR(ek))
 968                 return ERR_PTR(PTR_ERR(ek));
 969
 970         exp = exp_get_by_name(clp, ek->ek_mnt, ek->ek_dentry, reqp);
 971         expkey_put(&ek->h, &svc_expkey_cache);
 972
 973         if (!exp || IS_ERR(exp))
 974                 return ERR_PTR(PTR_ERR(exp));
 975         return exp;
 976 }
 977
 978
 979 /*
 980  * Called when we need the filehandle for the root of the pseudofs,
 981  * for a given NFSv4 client.   The root is defined to be the
 982  * export point with fsid==0
 983  */
 984 int
 985 exp_pseudoroot(struct auth_domain *clp, struct svc_fh *fhp,
 986                struct cache_req *creq)
 987 {
 988         struct svc_expkey *fsid_key;
 989         struct svc_export *exp;
 990         int rv;
 991         u32 fsidv[2];
 992
 993         mk_fsid_v1(fsidv, 0);
 994
 995         fsid_key = exp_find_key(clp, 1, fsidv, creq);
 996         if (IS_ERR(fsid_key) && PTR_ERR(fsid_key) == -EAGAIN)
 997                 return nfserr_dropit;
 998         if (!fsid_key || IS_ERR(fsid_key))
 999                 return nfserr_perm;
1000
1001         exp = exp_get_by_name(clp, fsid_key->ek_mnt, fsid_key->ek_dentry, creq);
1002         if (exp == NULL)
1003                 rv = nfserr_perm;
1004         else if (IS_ERR(exp))
1005                 rv = nfserrno(PTR_ERR(exp));
1006         else
1007                 rv = fh_compose(fhp, exp,
1008                                 fsid_key->ek_dentry, NULL);
1009         expkey_put(&fsid_key->h, &svc_expkey_cache);
1010         return rv;
1011 }
1012
1013 /* Iterator */
1014
1015 static void *e_start(struct seq_file *m, loff_t *pos)
1016 {
1017         loff_t n = *pos;
1018         unsigned hash, export;
1019         struct cache_head *ch;
1020
1021         exp_readlock();
1022         read_lock(&svc_export_cache.hash_lock);
1023         if (!n--)
1024                 return (void *)1;
1025         hash = n >> 32;
1026         export = n & ((1LL<<32) - 1);
1027
1028
1029         for (ch=export_table[hash]; ch; ch=ch->next)
1030                 if (!export--)
1031                         return ch;
1032         n &= ~((1LL<<32) - 1);
1033         do {
1034                 hash++;
1035                 n += 1LL<<32;
1036         } while(hash < EXPORT_HASHMAX && export_table[hash]==NULL);
1037         if (hash >= EXPORT_HASHMAX)
1038                 return NULL;
1039         *pos = n+1;
1040         return export_table[hash];
1041 }
1042
1043 static void *e_next(struct seq_file *m, void *p, loff_t *pos)
1044 {
1045         struct cache_head *ch = p;
1046         int hash = (*pos >> 32);
1047
1048         if (p == (void *)1)
1049                 hash = 0;
1050         else if (ch->next == NULL) {
1051                 hash++;
1052                 *pos += 1LL<<32;
1053         } else {
1054                 ++*pos;
1055                 return ch->next;
1056         }
1057         *pos &= ~((1LL<<32) - 1);
1058         while (hash < EXPORT_HASHMAX && export_table[hash] == NULL) {
1059                 hash++;
1060                 *pos += 1LL<<32;
1061         }
1062         if (hash >= EXPORT_HASHMAX)
1063                 return NULL;
1064         ++*pos;
1065         return export_table[hash];
1066 }
1067
1068 static void e_stop(struct seq_file *m, void *p)
1069 {
1070         read_unlock(&svc_export_cache.hash_lock);
1071         exp_readunlock();
1072 }
1073
1074 static struct flags {
1075         int flag;
1076         char *name[2];
1077 } expflags[] = {
1078         { NFSEXP_READONLY, {"ro", "rw"}},
1079         { NFSEXP_INSECURE_PORT, {"insecure", ""}},
1080         { NFSEXP_ROOTSQUASH, {"root_squash", "no_root_squash"}},
1081         { NFSEXP_ALLSQUASH, {"all_squash", ""}},
1082         { NFSEXP_ASYNC, {"async", "sync"}},
1083         { NFSEXP_GATHERED_WRITES, {"wdelay", "no_wdelay"}},
1084         { NFSEXP_NOHIDE, {"nohide", ""}},
1085         { NFSEXP_CROSSMOUNT, {"crossmnt", ""}},
1086         { NFSEXP_NOSUBTREECHECK, {"no_subtree_check", ""}},
1087         { NFSEXP_NOAUTHNLM, {"insecure_locks", ""}},
1088 #ifdef MSNFS
1089         { NFSEXP_MSNFS, {"msnfs", ""}},
1090 #endif
1091         { 0, {"", ""}}
1092 };
1093
1094 static void exp_flags(struct seq_file *m, int flag, int fsid, uid_t anonu, uid_t anong)
1095 {
1096         int first = 0;
1097         struct flags *flg;
1098
1099         for (flg = expflags; flg->flag; flg++) {
1100                 int state = (flg->flag & flag)?0:1;
1101                 if (*flg->name[state])
1102                         seq_printf(m, "%s%s", first++?",":"", flg->name[state]);
1103         }
1104         if (flag & NFSEXP_FSID)
1105                 seq_printf(m, "%sfsid=%d", first++?",":"", fsid);
1106         if (anonu != (uid_t)-2 && anonu != (0x10000-2))
1107                 seq_printf(m, "%sanonuid=%d", first++?",":"", anonu);
1108         if (anong != (gid_t)-2 && anong != (0x10000-2))
1109                 seq_printf(m, "%sanongid=%d", first++?",":"", anong);
1110 }
1111
1112 static int e_show(struct seq_file *m, void *p)
1113 {
1114         struct cache_head *cp = p;
1115         struct svc_export *exp = container_of(cp, struct svc_export, h);
1116         svc_client *clp;
1117
1118         if (p == (void *)1) {
1119                 seq_puts(m, "# Version 1.1\n");
1120                 seq_puts(m, "# Path Client(Flags) # IPs\n");
1121                 return 0;
1122         }
1123
1124         clp = exp->ex_client;
1125         cache_get(&exp->h);
1126         if (cache_check(&svc_export_cache, &exp->h, NULL))
1127                 return 0;
1128         if (cache_put(&exp->h, &svc_export_cache)) BUG();
1129         return svc_export_show(m, &svc_export_cache, cp);
1130 }
1131
1132 struct seq_operations nfs_exports_op = {
1133         .start  = e_start,
1134         .next   = e_next,
1135         .stop   = e_stop,
1136         .show   = e_show,
1137 };
1138
1139 /*
1140  * Add or modify a client.
1141  * Change requests may involve the list of host addresses. The list of
1142  * exports and possibly existing uid maps are left untouched.
1143  */
1144 int
1145 exp_addclient(struct nfsctl_client *ncp)
1146 {
1147         struct auth_domain      *dom;
1148         int                     i, err;
1149
1150         /* First, consistency check. */
1151         err = -EINVAL;
1152         if (! exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1153                 goto out;
1154         if (ncp->cl_naddr > NFSCLNT_ADDRMAX)
1155                 goto out;
1156
1157         /* Lock the hashtable */
1158         exp_writelock();
1159
1160         dom = unix_domain_find(ncp->cl_ident);
1161
1162         err = -ENOMEM;
1163         if (!dom)
1164                 goto out_unlock;
1165
1166         /* Insert client into hashtable. */
1167         for (i = 0; i < ncp->cl_naddr; i++)
1168                 auth_unix_add_addr(ncp->cl_addrlist[i], dom);
1169
1170         auth_unix_forget_old(dom);
1171         auth_domain_put(dom);
1172
1173         err = 0;
1174
1175 out_unlock:
1176         exp_writeunlock();
1177 out:
1178         return err;
1179 }
1180
1181 /*
1182  * Delete a client given an identifier.
1183  */
1184 int
1185 exp_delclient(struct nfsctl_client *ncp)
1186 {
1187         int             err;
1188         struct auth_domain *dom;
1189
1190         err = -EINVAL;
1191         if (!exp_verify_string(ncp->cl_ident, NFSCLNT_IDMAX))
1192                 goto out;
1193
1194         /* Lock the hashtable */
1195         exp_writelock();
1196
1197         dom = auth_domain_find(ncp->cl_ident);
1198         /* just make sure that no addresses work
1199          * and that it will expire soon
1200          */
1201         if (dom) {
1202                 err = auth_unix_forget_old(dom);
1203                 auth_domain_put(dom);
1204         }
1205
1206         exp_writeunlock();
1207 out:
1208         return err;
1209 }
1210
1211 /*
1212  * Verify that string is non-empty and does not exceed max length.
1213  */
1214 static int
1215 exp_verify_string(char *cp, int max)
1216 {
1217         int     i;
1218
1219         for (i = 0; i < max; i++)
1220                 if (!cp[i])
1221                         return i;
1222         cp[i] = 0;
1223         printk(KERN_NOTICE "nfsd: couldn't validate string %s\n", cp);
1224         return 0;
1225 }
1226
1227 /*
1228  * Initialize the exports module.
1229  */
1230 void
1231 nfsd_export_init(void)
1232 {
1233         dprintk("nfsd: initializing export module.\n");
1234
1235         cache_register(&svc_export_cache);
1236         cache_register(&svc_expkey_cache);
1237
1238 }
1239
1240 /*
1241  * Flush exports table - called when last nfsd thread is killed
1242  */
1243 void
1244 nfsd_export_flush(void)
1245 {
1246         exp_writelock();
1247         cache_purge(&svc_expkey_cache);
1248         cache_purge(&svc_export_cache);
1249         exp_writeunlock();
1250 }
1251
1252 /*
1253  * Shutdown the exports module.
1254  */
1255 void
1256 nfsd_export_shutdown(void)
1257 {
1258
1259         dprintk("nfsd: shutting down export module.\n");
1260
1261         exp_writelock();
1262
1263         if (cache_unregister(&svc_expkey_cache))
1264                 printk(KERN_ERR "nfsd: failed to unregister expkey cache\n");
1265         if (cache_unregister(&svc_export_cache))
1266                 printk(KERN_ERR "nfsd: failed to unregister export cache\n");
1267         svcauth_unix_purge();
1268
1269         exp_writeunlock();
1270         dprintk("nfsd: export shutdown complete.\n");
1271 }