[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / fs / nfsd / nfs4idmap.c
1 /*
2  *  fs/nfsd/nfs4idmap.c
3  *
4  *  Mapping of UID/GIDs to name and vice versa.
5  *
6  *  Copyright (c) 2002, 2003 The Regents of the University of
7  *  Michigan.  All rights reserved.
8  *
9  *  Marius Aamodt Eriksen <marius@umich.edu>
10  *
11  *  Redistribution and use in source and binary forms, with or without
12  *  modification, are permitted provided that the following conditions
13  *  are met:
14  *
15  *  1. Redistributions of source code must retain the above copyright
16  *     notice, this list of conditions and the following disclaimer.
17  *  2. Redistributions in binary form must reproduce the above copyright
18  *     notice, this list of conditions and the following disclaimer in the
19  *     documentation and/or other materials provided with the distribution.
20  *  3. Neither the name of the University nor the names of its
21  *     contributors may be used to endorse or promote products derived
22  *     from this software without specific prior written permission.
23  *
24  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  */
36
37 #include <linux/module.h>
38 #include <linux/init.h>
39
40 #include <linux/mm.h>
41 #include <linux/utsname.h>
42 #include <linux/errno.h>
43 #include <linux/string.h>
44 #include <linux/sunrpc/clnt.h>
45 #include <linux/nfs.h>
46 #include <linux/nfs4.h>
47 #include <linux/nfs_fs.h>
48 #include <linux/nfs_page.h>
49 #include <linux/smp_lock.h>
50 #include <linux/sunrpc/cache.h>
51 #include <linux/nfsd_idmap.h>
52 #include <linux/list.h>
53 #include <linux/time.h>
54 #include <linux/seq_file.h>
55 #include <linux/sunrpc/svcauth.h>
56
57 /*
58  * Cache entry
59  */
60
61 /*
62  * XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on
63  * that.
64  */
65
66 #define IDMAP_TYPE_USER  0
67 #define IDMAP_TYPE_GROUP 1
68
69 struct ent {
70         struct cache_head h;
71         int               type;                /* User / Group */
72         uid_t             id;
73         char              name[IDMAP_NAMESZ];
74         char              authname[IDMAP_NAMESZ];
75 };
76
77 /* Common entry handling */
78
79 #define ENT_HASHBITS          8
80 #define ENT_HASHMAX           (1 << ENT_HASHBITS)
81 #define ENT_HASHMASK          (ENT_HASHMAX - 1)
82
83 static void
84 ent_init(struct cache_head *cnew, struct cache_head *citm)
85 {
86         struct ent *new = container_of(cnew, struct ent, h);
87         struct ent *itm = container_of(citm, struct ent, h);
88
89         new->id = itm->id;
90         new->type = itm->type;
91
92         strlcpy(new->name, itm->name, sizeof(new->name));
93         strlcpy(new->authname, itm->authname, sizeof(new->name));
94 }
95
96 static void
97 ent_put(struct kref *ref)
98 {
99         struct ent *map = container_of(ref, struct ent, h.ref);
100         kfree(map);
101 }
102
103 static struct cache_head *
104 ent_alloc(void)
105 {
106         struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
107         if (e)
108                 return &e->h;
109         else
110                 return NULL;
111 }
112
113 /*
114  * ID -> Name cache
115  */
116
117 static struct cache_head *idtoname_table[ENT_HASHMAX];
118
119 static uint32_t
120 idtoname_hash(struct ent *ent)
121 {
122         uint32_t hash;
123
124         hash = hash_str(ent->authname, ENT_HASHBITS);
125         hash = hash_long(hash ^ ent->id, ENT_HASHBITS);
126
127         /* Flip LSB for user/group */
128         if (ent->type == IDMAP_TYPE_GROUP)
129                 hash ^= 1;
130
131         return hash;
132 }
133
134 static void
135 idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
136     int *blen)
137 {
138         struct ent *ent = container_of(ch, struct ent, h);
139         char idstr[11];
140
141         qword_add(bpp, blen, ent->authname);
142         snprintf(idstr, sizeof(idstr), "%d", ent->id);
143         qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
144         qword_add(bpp, blen, idstr);
145
146         (*bpp)[-1] = '\n';
147 }
148
149 static int
150 idtoname_match(struct cache_head *ca, struct cache_head *cb)
151 {
152         struct ent *a = container_of(ca, struct ent, h);
153         struct ent *b = container_of(cb, struct ent, h);
154
155         return (a->id == b->id && a->type == b->type &&
156             strcmp(a->authname, b->authname) == 0);
157 }
158
159 static int
160 idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
161 {
162         struct ent *ent;
163
164         if (h == NULL) {
165                 seq_puts(m, "#domain type id [name]\n");
166                 return 0;
167         }
168         ent = container_of(h, struct ent, h);
169         seq_printf(m, "%s %s %d", ent->authname,
170                         ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
171                         ent->id);
172         if (test_bit(CACHE_VALID, &h->flags))
173                 seq_printf(m, " %s", ent->name);
174         seq_printf(m, "\n");
175         return 0;
176 }
177
178 static void
179 warn_no_idmapd(struct cache_detail *detail)
180 {
181         printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
182                         detail->last_close? "died" : "not been started");
183 }
184
185
186 static int         idtoname_parse(struct cache_detail *, char *, int);
187 static struct ent *idtoname_lookup(struct ent *);
188 static struct ent *idtoname_update(struct ent *, struct ent *);
189
190 static struct cache_detail idtoname_cache = {
191         .owner          = THIS_MODULE,
192         .hash_size      = ENT_HASHMAX,
193         .hash_table     = idtoname_table,
194         .name           = "nfs4.idtoname",
195         .cache_put      = ent_put,
196         .cache_request  = idtoname_request,
197         .cache_parse    = idtoname_parse,
198         .cache_show     = idtoname_show,
199         .warn_no_listener = warn_no_idmapd,
200         .match          = idtoname_match,
201         .init           = ent_init,
202         .update         = ent_init,
203         .alloc          = ent_alloc,
204 };
205
206 int
207 idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
208 {
209         struct ent ent, *res;
210         char *buf1, *bp;
211         int error = -EINVAL;
212
213         if (buf[buflen - 1] != '\n')
214                 return (-EINVAL);
215         buf[buflen - 1]= '\0';
216
217         buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
218         if (buf1 == NULL)
219                 return (-ENOMEM);
220
221         memset(&ent, 0, sizeof(ent));
222
223         /* Authentication name */
224         if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
225                 goto out;
226         memcpy(ent.authname, buf1, sizeof(ent.authname));
227
228         /* Type */
229         if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
230                 goto out;
231         ent.type = strcmp(buf1, "user") == 0 ?
232                 IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
233
234         /* ID */
235         if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
236                 goto out;
237         ent.id = simple_strtoul(buf1, &bp, 10);
238         if (bp == buf1)
239                 goto out;
240
241         /* expiry */
242         ent.h.expiry_time = get_expiry(&buf);
243         if (ent.h.expiry_time == 0)
244                 goto out;
245
246         error = -ENOMEM;
247         res = idtoname_lookup(&ent);
248         if (!res)
249                 goto out;
250
251         /* Name */
252         error = qword_get(&buf, buf1, PAGE_SIZE);
253         if (error == -EINVAL)
254                 goto out;
255         if (error == -ENOENT)
256                 set_bit(CACHE_NEGATIVE, &ent.h.flags);
257         else {
258                 if (error >= IDMAP_NAMESZ) {
259                         error = -EINVAL;
260                         goto out;
261                 }
262                 memcpy(ent.name, buf1, sizeof(ent.name));
263         }
264         error = -ENOMEM;
265         res = idtoname_update(&ent, res);
266         if (res == NULL)
267                 goto out;
268
269         cache_put(&res->h, &idtoname_cache);
270
271         error = 0;
272 out:
273         kfree(buf1);
274
275         return error;
276 }
277
278
279 static struct ent *
280 idtoname_lookup(struct ent *item)
281 {
282         struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
283                                                     &item->h,
284                                                     idtoname_hash(item));
285         if (ch)
286                 return container_of(ch, struct ent, h);
287         else
288                 return NULL;
289 }
290
291 static struct ent *
292 idtoname_update(struct ent *new, struct ent *old)
293 {
294         struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
295                                                     &new->h, &old->h,
296                                                     idtoname_hash(new));
297         if (ch)
298                 return container_of(ch, struct ent, h);
299         else
300                 return NULL;
301 }
302
303
304 /*
305  * Name -> ID cache
306  */
307
308 static struct cache_head *nametoid_table[ENT_HASHMAX];
309
310 static inline int
311 nametoid_hash(struct ent *ent)
312 {
313         return hash_str(ent->name, ENT_HASHBITS);
314 }
315
316 static void
317 nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
318     int *blen)
319 {
320         struct ent *ent = container_of(ch, struct ent, h);
321
322         qword_add(bpp, blen, ent->authname);
323         qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
324         qword_add(bpp, blen, ent->name);
325
326         (*bpp)[-1] = '\n';
327 }
328
329 static int
330 nametoid_match(struct cache_head *ca, struct cache_head *cb)
331 {
332         struct ent *a = container_of(ca, struct ent, h);
333         struct ent *b = container_of(cb, struct ent, h);
334
335         return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
336             strcmp(a->authname, b->authname) == 0);
337 }
338
339 static int
340 nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
341 {
342         struct ent *ent;
343
344         if (h == NULL) {
345                 seq_puts(m, "#domain type name [id]\n");
346                 return 0;
347         }
348         ent = container_of(h, struct ent, h);
349         seq_printf(m, "%s %s %s", ent->authname,
350                         ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
351                         ent->name);
352         if (test_bit(CACHE_VALID, &h->flags))
353                 seq_printf(m, " %d", ent->id);
354         seq_printf(m, "\n");
355         return 0;
356 }
357
358 static struct ent *nametoid_lookup(struct ent *);
359 static struct ent *nametoid_update(struct ent *, struct ent *);
360 static int         nametoid_parse(struct cache_detail *, char *, int);
361
362 static struct cache_detail nametoid_cache = {
363         .owner          = THIS_MODULE,
364         .hash_size      = ENT_HASHMAX,
365         .hash_table     = nametoid_table,
366         .name           = "nfs4.nametoid",
367         .cache_put      = ent_put,
368         .cache_request  = nametoid_request,
369         .cache_parse    = nametoid_parse,
370         .cache_show     = nametoid_show,
371         .warn_no_listener = warn_no_idmapd,
372         .match          = nametoid_match,
373         .init           = ent_init,
374         .update         = ent_init,
375         .alloc          = ent_alloc,
376 };
377
378 static int
379 nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
380 {
381         struct ent ent, *res;
382         char *buf1;
383         int error = -EINVAL;
384
385         if (buf[buflen - 1] != '\n')
386                 return (-EINVAL);
387         buf[buflen - 1]= '\0';
388
389         buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
390         if (buf1 == NULL)
391                 return (-ENOMEM);
392
393         memset(&ent, 0, sizeof(ent));
394
395         /* Authentication name */
396         if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
397                 goto out;
398         memcpy(ent.authname, buf1, sizeof(ent.authname));
399
400         /* Type */
401         if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
402                 goto out;
403         ent.type = strcmp(buf1, "user") == 0 ?
404                 IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
405
406         /* Name */
407         error = qword_get(&buf, buf1, PAGE_SIZE);
408         if (error <= 0 || error >= IDMAP_NAMESZ)
409                 goto out;
410         memcpy(ent.name, buf1, sizeof(ent.name));
411
412         /* expiry */
413         ent.h.expiry_time = get_expiry(&buf);
414         if (ent.h.expiry_time == 0)
415                 goto out;
416
417         /* ID */
418         error = get_int(&buf, &ent.id);
419         if (error == -EINVAL)
420                 goto out;
421         if (error == -ENOENT)
422                 set_bit(CACHE_NEGATIVE, &ent.h.flags);
423
424         error = -ENOMEM;
425         res = nametoid_lookup(&ent);
426         if (res == NULL)
427                 goto out;
428         res = nametoid_update(&ent, res);
429         if (res == NULL)
430                 goto out;
431
432         cache_put(&res->h, &nametoid_cache);
433         error = 0;
434 out:
435         kfree(buf1);
436
437         return (error);
438 }
439
440
441 static struct ent *
442 nametoid_lookup(struct ent *item)
443 {
444         struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
445                                                     &item->h,
446                                                     nametoid_hash(item));
447         if (ch)
448                 return container_of(ch, struct ent, h);
449         else
450                 return NULL;
451 }
452
453 static struct ent *
454 nametoid_update(struct ent *new, struct ent *old)
455 {
456         struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
457                                                     &new->h, &old->h,
458                                                     nametoid_hash(new));
459         if (ch)
460                 return container_of(ch, struct ent, h);
461         else
462                 return NULL;
463 }
464
465 /*
466  * Exported API
467  */
468
469 void
470 nfsd_idmap_init(void)
471 {
472         cache_register(&idtoname_cache);
473         cache_register(&nametoid_cache);
474 }
475
476 void
477 nfsd_idmap_shutdown(void)
478 {
479         if (cache_unregister(&idtoname_cache))
480                 printk(KERN_ERR "nfsd: failed to unregister idtoname cache\n");
481         if (cache_unregister(&nametoid_cache))
482                 printk(KERN_ERR "nfsd: failed to unregister nametoid cache\n");
483 }
484
485 /*
486  * Deferred request handling
487  */
488
489 struct idmap_defer_req {
490        struct cache_req         req;
491        struct cache_deferred_req deferred_req;
492        wait_queue_head_t        waitq;
493        atomic_t                 count;
494 };
495
496 static inline void
497 put_mdr(struct idmap_defer_req *mdr)
498 {
499         if (atomic_dec_and_test(&mdr->count))
500                 kfree(mdr);
501 }
502
503 static inline void
504 get_mdr(struct idmap_defer_req *mdr)
505 {
506         atomic_inc(&mdr->count);
507 }
508
509 static void
510 idmap_revisit(struct cache_deferred_req *dreq, int toomany)
511 {
512         struct idmap_defer_req *mdr =
513                 container_of(dreq, struct idmap_defer_req, deferred_req);
514
515         wake_up(&mdr->waitq);
516         put_mdr(mdr);
517 }
518
519 static struct cache_deferred_req *
520 idmap_defer(struct cache_req *req)
521 {
522         struct idmap_defer_req *mdr =
523                 container_of(req, struct idmap_defer_req, req);
524
525         mdr->deferred_req.revisit = idmap_revisit;
526         get_mdr(mdr);
527         return (&mdr->deferred_req);
528 }
529
530 static inline int
531 do_idmap_lookup(struct ent *(*lookup_fn)(struct ent *), struct ent *key,
532                 struct cache_detail *detail, struct ent **item,
533                 struct idmap_defer_req *mdr)
534 {
535         *item = lookup_fn(key);
536         if (!*item)
537                 return -ENOMEM;
538         return cache_check(detail, &(*item)->h, &mdr->req);
539 }
540
541 static inline int
542 do_idmap_lookup_nowait(struct ent *(*lookup_fn)(struct ent *),
543                         struct ent *key, struct cache_detail *detail,
544                         struct ent **item)
545 {
546         int ret = -ENOMEM;
547
548         *item = lookup_fn(key);
549         if (!*item)
550                 goto out_err;
551         ret = -ETIMEDOUT;
552         if (!test_bit(CACHE_VALID, &(*item)->h.flags)
553                         || (*item)->h.expiry_time < get_seconds()
554                         || detail->flush_time > (*item)->h.last_refresh)
555                 goto out_put;
556         ret = -ENOENT;
557         if (test_bit(CACHE_NEGATIVE, &(*item)->h.flags))
558                 goto out_put;
559         return 0;
560 out_put:
561         cache_put(&(*item)->h, detail);
562 out_err:
563         *item = NULL;
564         return ret;
565 }
566
567 static int
568 idmap_lookup(struct svc_rqst *rqstp,
569                 struct ent *(*lookup_fn)(struct ent *), struct ent *key,
570                 struct cache_detail *detail, struct ent **item)
571 {
572         struct idmap_defer_req *mdr;
573         int ret;
574
575         mdr = kzalloc(sizeof(*mdr), GFP_KERNEL);
576         if (!mdr)
577                 return -ENOMEM;
578         atomic_set(&mdr->count, 1);
579         init_waitqueue_head(&mdr->waitq);
580         mdr->req.defer = idmap_defer;
581         ret = do_idmap_lookup(lookup_fn, key, detail, item, mdr);
582         if (ret == -EAGAIN) {
583                 wait_event_interruptible_timeout(mdr->waitq,
584                         test_bit(CACHE_VALID, &(*item)->h.flags), 1 * HZ);
585                 ret = do_idmap_lookup_nowait(lookup_fn, key, detail, item);
586         }
587         put_mdr(mdr);
588         return ret;
589 }
590
591 static int
592 idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen,
593                 uid_t *id)
594 {
595         struct ent *item, key = {
596                 .type = type,
597         };
598         int ret;
599
600         if (namelen + 1 > sizeof(key.name))
601                 return -EINVAL;
602         memcpy(key.name, name, namelen);
603         key.name[namelen] = '\0';
604         strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
605         ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);
606         if (ret == -ENOENT)
607                 ret = -ESRCH; /* nfserr_badname */
608         if (ret)
609                 return ret;
610         *id = item->id;
611         cache_put(&item->h, &nametoid_cache);
612         return 0;
613 }
614
615 static int
616 idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
617 {
618         struct ent *item, key = {
619                 .id = id,
620                 .type = type,
621         };
622         int ret;
623
624         strlcpy(key.authname, rqstp->rq_client->name, sizeof(key.authname));
625         ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);
626         if (ret == -ENOENT)
627                 return sprintf(name, "%u", id);
628         if (ret)
629                 return ret;
630         ret = strlen(item->name);
631         BUG_ON(ret > IDMAP_NAMESZ);
632         memcpy(name, item->name, ret);
633         cache_put(&item->h, &idtoname_cache);
634         return ret;
635 }
636
637 int
638 nfsd_map_name_to_uid(struct svc_rqst *rqstp, const char *name, size_t namelen,
639                 __u32 *id)
640 {
641         return idmap_name_to_id(rqstp, IDMAP_TYPE_USER, name, namelen, id);
642 }
643
644 int
645 nfsd_map_name_to_gid(struct svc_rqst *rqstp, const char *name, size_t namelen,
646                 __u32 *id)
647 {
648         return idmap_name_to_id(rqstp, IDMAP_TYPE_GROUP, name, namelen, id);
649 }
650
651 int
652 nfsd_map_uid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
653 {
654         return idmap_id_to_name(rqstp, IDMAP_TYPE_USER, id, name);
655 }
656
657 int
658 nfsd_map_gid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
659 {
660         return idmap_id_to_name(rqstp, IDMAP_TYPE_GROUP, id, name);
661 }