4 * Mapping of UID/GIDs to name and vice versa.
6 * Copyright (c) 2002, 2003 The Regents of the University of
7 * Michigan. All rights reserved.
9 * Marius Aamodt Eriksen <marius@umich.edu>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
37 #include <linux/config.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
42 #include <linux/utsname.h>
43 #include <linux/errno.h>
44 #include <linux/string.h>
45 #include <linux/sunrpc/clnt.h>
46 #include <linux/nfs.h>
47 #include <linux/nfs4.h>
48 #include <linux/nfs_fs.h>
49 #include <linux/nfs_page.h>
50 #include <linux/smp_lock.h>
51 #include <linux/sunrpc/cache.h>
52 #include <linux/nfsd_idmap.h>
53 #include <linux/list.h>
54 #include <linux/sched.h>
55 #include <linux/time.h>
56 #include <linux/seq_file.h>
57 #include <linux/sunrpc/svcauth.h>
64 * XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on
68 #define IDMAP_TYPE_USER 0
69 #define IDMAP_TYPE_GROUP 1
73 int type
; /* User / Group */
75 char name
[IDMAP_NAMESZ
];
76 char authname
[IDMAP_NAMESZ
];
79 /* Common entry handling */
81 #define ENT_HASHBITS 8
82 #define ENT_HASHMAX (1 << ENT_HASHBITS)
83 #define ENT_HASHMASK (ENT_HASHMAX - 1)
86 ent_init(struct cache_head
*cnew
, struct cache_head
*citm
)
88 struct ent
*new = container_of(cnew
, struct ent
, h
);
89 struct ent
*itm
= container_of(citm
, struct ent
, h
);
92 new->type
= itm
->type
;
94 strlcpy(new->name
, itm
->name
, sizeof(new->name
));
95 strlcpy(new->authname
, itm
->authname
, sizeof(new->name
));
99 ent_put(struct cache_head
*ch
, struct cache_detail
*cd
)
101 if (cache_put(ch
, cd
)) {
102 struct ent
*map
= container_of(ch
, struct ent
, h
);
107 static struct cache_head
*
110 struct ent
*e
= kmalloc(sizeof(*e
), GFP_KERNEL
);
121 static struct cache_head
*idtoname_table
[ENT_HASHMAX
];
124 idtoname_hash(struct ent
*ent
)
128 hash
= hash_str(ent
->authname
, ENT_HASHBITS
);
129 hash
= hash_long(hash
^ ent
->id
, ENT_HASHBITS
);
131 /* Flip LSB for user/group */
132 if (ent
->type
== IDMAP_TYPE_GROUP
)
139 idtoname_request(struct cache_detail
*cd
, struct cache_head
*ch
, char **bpp
,
142 struct ent
*ent
= container_of(ch
, struct ent
, h
);
145 qword_add(bpp
, blen
, ent
->authname
);
146 snprintf(idstr
, sizeof(idstr
), "%d", ent
->id
);
147 qword_add(bpp
, blen
, ent
->type
== IDMAP_TYPE_GROUP
? "group" : "user");
148 qword_add(bpp
, blen
, idstr
);
154 idtoname_match(struct cache_head
*ca
, struct cache_head
*cb
)
156 struct ent
*a
= container_of(ca
, struct ent
, h
);
157 struct ent
*b
= container_of(cb
, struct ent
, h
);
159 return (a
->id
== b
->id
&& a
->type
== b
->type
&&
160 strcmp(a
->authname
, b
->authname
) == 0);
164 idtoname_show(struct seq_file
*m
, struct cache_detail
*cd
, struct cache_head
*h
)
169 seq_puts(m
, "#domain type id [name]\n");
172 ent
= container_of(h
, struct ent
, h
);
173 seq_printf(m
, "%s %s %d", ent
->authname
,
174 ent
->type
== IDMAP_TYPE_GROUP
? "group" : "user",
176 if (test_bit(CACHE_VALID
, &h
->flags
))
177 seq_printf(m
, " %s", ent
->name
);
183 warn_no_idmapd(struct cache_detail
*detail
)
185 printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
186 detail
->last_close
? "died" : "not been started");
190 static int idtoname_parse(struct cache_detail
*, char *, int);
191 static struct ent
*idtoname_lookup(struct ent
*);
192 static struct ent
*idtoname_update(struct ent
*, struct ent
*);
194 static struct cache_detail idtoname_cache
= {
195 .owner
= THIS_MODULE
,
196 .hash_size
= ENT_HASHMAX
,
197 .hash_table
= idtoname_table
,
198 .name
= "nfs4.idtoname",
199 .cache_put
= ent_put
,
200 .cache_request
= idtoname_request
,
201 .cache_parse
= idtoname_parse
,
202 .cache_show
= idtoname_show
,
203 .warn_no_listener
= warn_no_idmapd
,
204 .match
= idtoname_match
,
211 idtoname_parse(struct cache_detail
*cd
, char *buf
, int buflen
)
213 struct ent ent
, *res
;
217 if (buf
[buflen
- 1] != '\n')
219 buf
[buflen
- 1]= '\0';
221 buf1
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
225 memset(&ent
, 0, sizeof(ent
));
227 /* Authentication name */
228 if (qword_get(&buf
, buf1
, PAGE_SIZE
) <= 0)
230 memcpy(ent
.authname
, buf1
, sizeof(ent
.authname
));
233 if (qword_get(&buf
, buf1
, PAGE_SIZE
) <= 0)
235 ent
.type
= strcmp(buf1
, "user") == 0 ?
236 IDMAP_TYPE_USER
: IDMAP_TYPE_GROUP
;
239 if (qword_get(&buf
, buf1
, PAGE_SIZE
) <= 0)
241 ent
.id
= simple_strtoul(buf1
, &bp
, 10);
246 ent
.h
.expiry_time
= get_expiry(&buf
);
247 if (ent
.h
.expiry_time
== 0)
251 res
= idtoname_lookup(&ent
);
256 error
= qword_get(&buf
, buf1
, PAGE_SIZE
);
257 if (error
== -EINVAL
)
259 if (error
== -ENOENT
)
260 set_bit(CACHE_NEGATIVE
, &ent
.h
.flags
);
262 if (error
>= IDMAP_NAMESZ
) {
266 memcpy(ent
.name
, buf1
, sizeof(ent
.name
));
269 res
= idtoname_update(&ent
, res
);
273 ent_put(&res
->h
, &idtoname_cache
);
284 idtoname_lookup(struct ent
*item
)
286 struct cache_head
*ch
= sunrpc_cache_lookup(&idtoname_cache
,
288 idtoname_hash(item
));
290 return container_of(ch
, struct ent
, h
);
296 idtoname_update(struct ent
*new, struct ent
*old
)
298 struct cache_head
*ch
= sunrpc_cache_update(&idtoname_cache
,
302 return container_of(ch
, struct ent
, h
);
312 static struct cache_head
*nametoid_table
[ENT_HASHMAX
];
315 nametoid_hash(struct ent
*ent
)
317 return hash_str(ent
->name
, ENT_HASHBITS
);
321 nametoid_request(struct cache_detail
*cd
, struct cache_head
*ch
, char **bpp
,
324 struct ent
*ent
= container_of(ch
, struct ent
, h
);
326 qword_add(bpp
, blen
, ent
->authname
);
327 qword_add(bpp
, blen
, ent
->type
== IDMAP_TYPE_GROUP
? "group" : "user");
328 qword_add(bpp
, blen
, ent
->name
);
334 nametoid_match(struct cache_head
*ca
, struct cache_head
*cb
)
336 struct ent
*a
= container_of(ca
, struct ent
, h
);
337 struct ent
*b
= container_of(cb
, struct ent
, h
);
339 return (a
->type
== b
->type
&& strcmp(a
->name
, b
->name
) == 0 &&
340 strcmp(a
->authname
, b
->authname
) == 0);
344 nametoid_show(struct seq_file
*m
, struct cache_detail
*cd
, struct cache_head
*h
)
349 seq_puts(m
, "#domain type name [id]\n");
352 ent
= container_of(h
, struct ent
, h
);
353 seq_printf(m
, "%s %s %s", ent
->authname
,
354 ent
->type
== IDMAP_TYPE_GROUP
? "group" : "user",
356 if (test_bit(CACHE_VALID
, &h
->flags
))
357 seq_printf(m
, " %d", ent
->id
);
362 static struct ent
*nametoid_lookup(struct ent
*);
363 static struct ent
*nametoid_update(struct ent
*, struct ent
*);
364 static int nametoid_parse(struct cache_detail
*, char *, int);
366 static struct cache_detail nametoid_cache
= {
367 .owner
= THIS_MODULE
,
368 .hash_size
= ENT_HASHMAX
,
369 .hash_table
= nametoid_table
,
370 .name
= "nfs4.nametoid",
371 .cache_put
= ent_put
,
372 .cache_request
= nametoid_request
,
373 .cache_parse
= nametoid_parse
,
374 .cache_show
= nametoid_show
,
375 .warn_no_listener
= warn_no_idmapd
,
376 .match
= nametoid_match
,
383 nametoid_parse(struct cache_detail
*cd
, char *buf
, int buflen
)
385 struct ent ent
, *res
;
389 if (buf
[buflen
- 1] != '\n')
391 buf
[buflen
- 1]= '\0';
393 buf1
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
397 memset(&ent
, 0, sizeof(ent
));
399 /* Authentication name */
400 if (qword_get(&buf
, buf1
, PAGE_SIZE
) <= 0)
402 memcpy(ent
.authname
, buf1
, sizeof(ent
.authname
));
405 if (qword_get(&buf
, buf1
, PAGE_SIZE
) <= 0)
407 ent
.type
= strcmp(buf1
, "user") == 0 ?
408 IDMAP_TYPE_USER
: IDMAP_TYPE_GROUP
;
411 error
= qword_get(&buf
, buf1
, PAGE_SIZE
);
412 if (error
<= 0 || error
>= IDMAP_NAMESZ
)
414 memcpy(ent
.name
, buf1
, sizeof(ent
.name
));
417 ent
.h
.expiry_time
= get_expiry(&buf
);
418 if (ent
.h
.expiry_time
== 0)
422 error
= get_int(&buf
, &ent
.id
);
423 if (error
== -EINVAL
)
425 if (error
== -ENOENT
)
426 set_bit(CACHE_NEGATIVE
, &ent
.h
.flags
);
429 res
= nametoid_lookup(&ent
);
432 res
= nametoid_update(&ent
, res
);
436 ent_put(&res
->h
, &nametoid_cache
);
446 nametoid_lookup(struct ent
*item
)
448 struct cache_head
*ch
= sunrpc_cache_lookup(&nametoid_cache
,
450 nametoid_hash(item
));
452 return container_of(ch
, struct ent
, h
);
458 nametoid_update(struct ent
*new, struct ent
*old
)
460 struct cache_head
*ch
= sunrpc_cache_update(&nametoid_cache
,
464 return container_of(ch
, struct ent
, h
);
474 nfsd_idmap_init(void)
476 cache_register(&idtoname_cache
);
477 cache_register(&nametoid_cache
);
481 nfsd_idmap_shutdown(void)
483 if (cache_unregister(&idtoname_cache
))
484 printk(KERN_ERR
"nfsd: failed to unregister idtoname cache\n");
485 if (cache_unregister(&nametoid_cache
))
486 printk(KERN_ERR
"nfsd: failed to unregister nametoid cache\n");
490 * Deferred request handling
493 struct idmap_defer_req
{
494 struct cache_req req
;
495 struct cache_deferred_req deferred_req
;
496 wait_queue_head_t waitq
;
501 put_mdr(struct idmap_defer_req
*mdr
)
503 if (atomic_dec_and_test(&mdr
->count
))
508 get_mdr(struct idmap_defer_req
*mdr
)
510 atomic_inc(&mdr
->count
);
514 idmap_revisit(struct cache_deferred_req
*dreq
, int toomany
)
516 struct idmap_defer_req
*mdr
=
517 container_of(dreq
, struct idmap_defer_req
, deferred_req
);
519 wake_up(&mdr
->waitq
);
523 static struct cache_deferred_req
*
524 idmap_defer(struct cache_req
*req
)
526 struct idmap_defer_req
*mdr
=
527 container_of(req
, struct idmap_defer_req
, req
);
529 mdr
->deferred_req
.revisit
= idmap_revisit
;
531 return (&mdr
->deferred_req
);
535 do_idmap_lookup(struct ent
*(*lookup_fn
)(struct ent
*), struct ent
*key
,
536 struct cache_detail
*detail
, struct ent
**item
,
537 struct idmap_defer_req
*mdr
)
539 *item
= lookup_fn(key
);
542 return cache_check(detail
, &(*item
)->h
, &mdr
->req
);
546 do_idmap_lookup_nowait(struct ent
*(*lookup_fn
)(struct ent
*),
547 struct ent
*key
, struct cache_detail
*detail
,
552 *item
= lookup_fn(key
);
556 if (!test_bit(CACHE_VALID
, &(*item
)->h
.flags
)
557 || (*item
)->h
.expiry_time
< get_seconds()
558 || detail
->flush_time
> (*item
)->h
.last_refresh
)
561 if (test_bit(CACHE_NEGATIVE
, &(*item
)->h
.flags
))
565 ent_put(&(*item
)->h
, detail
);
572 idmap_lookup(struct svc_rqst
*rqstp
,
573 struct ent
*(*lookup_fn
)(struct ent
*), struct ent
*key
,
574 struct cache_detail
*detail
, struct ent
**item
)
576 struct idmap_defer_req
*mdr
;
579 mdr
= kmalloc(sizeof(*mdr
), GFP_KERNEL
);
582 memset(mdr
, 0, sizeof(*mdr
));
583 atomic_set(&mdr
->count
, 1);
584 init_waitqueue_head(&mdr
->waitq
);
585 mdr
->req
.defer
= idmap_defer
;
586 ret
= do_idmap_lookup(lookup_fn
, key
, detail
, item
, mdr
);
587 if (ret
== -EAGAIN
) {
588 wait_event_interruptible_timeout(mdr
->waitq
,
589 test_bit(CACHE_VALID
, &(*item
)->h
.flags
), 1 * HZ
);
590 ret
= do_idmap_lookup_nowait(lookup_fn
, key
, detail
, item
);
597 idmap_name_to_id(struct svc_rqst
*rqstp
, int type
, const char *name
, u32 namelen
,
600 struct ent
*item
, key
= {
605 if (namelen
+ 1 > sizeof(key
.name
))
607 memcpy(key
.name
, name
, namelen
);
608 key
.name
[namelen
] = '\0';
609 strlcpy(key
.authname
, rqstp
->rq_client
->name
, sizeof(key
.authname
));
610 ret
= idmap_lookup(rqstp
, nametoid_lookup
, &key
, &nametoid_cache
, &item
);
612 ret
= -ESRCH
; /* nfserr_badname */
616 ent_put(&item
->h
, &nametoid_cache
);
621 idmap_id_to_name(struct svc_rqst
*rqstp
, int type
, uid_t id
, char *name
)
623 struct ent
*item
, key
= {
629 strlcpy(key
.authname
, rqstp
->rq_client
->name
, sizeof(key
.authname
));
630 ret
= idmap_lookup(rqstp
, idtoname_lookup
, &key
, &idtoname_cache
, &item
);
632 return sprintf(name
, "%u", id
);
635 ret
= strlen(item
->name
);
636 BUG_ON(ret
> IDMAP_NAMESZ
);
637 memcpy(name
, item
->name
, ret
);
638 ent_put(&item
->h
, &idtoname_cache
);
643 nfsd_map_name_to_uid(struct svc_rqst
*rqstp
, const char *name
, size_t namelen
,
646 return idmap_name_to_id(rqstp
, IDMAP_TYPE_USER
, name
, namelen
, id
);
650 nfsd_map_name_to_gid(struct svc_rqst
*rqstp
, const char *name
, size_t namelen
,
653 return idmap_name_to_id(rqstp
, IDMAP_TYPE_GROUP
, name
, namelen
, id
);
657 nfsd_map_uid_to_name(struct svc_rqst
*rqstp
, __u32 id
, char *name
)
659 return idmap_id_to_name(rqstp
, IDMAP_TYPE_USER
, id
, name
);
663 nfsd_map_gid_to_name(struct svc_rqst
*rqstp
, __u32 id
, char *name
)
665 return idmap_id_to_name(rqstp
, IDMAP_TYPE_GROUP
, id
, name
);