lustre/mds/mds_lib.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #define DEBUG_SUBSYSTEM S_MDS
  23
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/mm.h>
  28 #include <linux/string.h>
  29 #include <linux/stat.h>
  30 #include <linux/errno.h>
  31 #include <linux/version.h>
  32 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  33 # include <linux/locks.h>   // for wait_on_buffer
  34 #else
  35 # include <linux/buffer_head.h>   // for wait_on_buffer
  36 #endif
  37 #include <linux/unistd.h>
  38
  39 #include <asm/system.h>
  40 #include <asm/uaccess.h>
  41
  42 #include <linux/fs.h>
  43 #include <linux/stat.h>
  44 #include <asm/uaccess.h>
  45 #include <linux/slab.h>
  46 #include <asm/segment.h>
  47
  48 #include <linux/obd_support.h>
  49 #include <linux/lustre_lib.h>
  50 #include "mds_internal.h"
  51
  52 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4)
  53 struct group_info *groups_alloc(int ngroups)
  54 {
  55         struct group_info *ginfo;
  56
  57         LASSERT(ngroups <= NGROUPS_SMALL);
  58
  59         OBD_ALLOC(ginfo, sizeof(*ginfo) + 1 * sizeof(gid_t *));
  60         if (!ginfo)
  61                 return NULL;
  62         ginfo->ngroups = ngroups;
  63         ginfo->nblocks = 1;
  64         ginfo->blocks[0] = ginfo->small_block;
  65         atomic_set(&ginfo->usage, 1);
  66
  67         return ginfo;
  68 }
  69
  70 void groups_free(struct group_info *ginfo)
  71 {
  72         LASSERT(ginfo->ngroups <= NGROUPS_SMALL);
  73         LASSERT(ginfo->nblocks == 1);
  74         LASSERT(ginfo->blocks[0] == ginfo->small_block);
  75
  76         OBD_FREE(ginfo, sizeof(*ginfo) + 1 * sizeof(gid_t *));
  77 }
  78
  79 /* for 2.4 the group number is small, so simply search the
  80  * whole array.
  81  */
  82 int groups_search(struct group_info *ginfo, gid_t grp)
  83 {
  84         int i;
  85
  86         if (!ginfo)
  87                 return 0;
  88
  89         for (i = 0; i < ginfo->ngroups; i++)
  90                 if (GROUP_AT(ginfo, i) == grp)
  91                         return 1;
  92         return 0;
  93 }
  94
  95 #else /* >= 2.6.4 */
  96
  97 void groups_sort(struct group_info *ginfo)
  98 {
  99         int base, max, stride;
 100         int gidsetsize = ginfo->ngroups;
 101
 102         for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
 103                 ; /* nothing */
 104         stride /= 3;
 105
 106         while (stride) {
 107                 max = gidsetsize - stride;
 108                 for (base = 0; base < max; base++) {
 109                         int left = base;
 110                         int right = left + stride;
 111                         gid_t tmp = GROUP_AT(ginfo, right);
 112
 113                         while (left >= 0 && GROUP_AT(ginfo, left) > tmp) {
 114                                 GROUP_AT(ginfo, right) =
 115                                     GROUP_AT(ginfo, left);
 116                                 right = left;
 117                                 left -= stride;
 118                         }
 119                         GROUP_AT(ginfo, right) = tmp;
 120                 }
 121                 stride /= 3;
 122         }
 123 }
 124
 125 int groups_search(struct group_info *ginfo, gid_t grp)
 126 {
 127         int left, right;
 128
 129         if (!ginfo)
 130                 return 0;
 131
 132         left = 0;
 133         right = ginfo->ngroups;
 134         while (left < right) {
 135                 int mid = (left + right) / 2;
 136                 int cmp = grp - GROUP_AT(ginfo, mid);
 137                 if (cmp > 0)
 138                         left = mid + 1;
 139                 else if (cmp < 0)
 140                         right = mid;
 141                 else
 142                         return 1;
 143         }
 144         return 0;
 145 }
 146 #endif
 147
 148 void groups_from_buffer(struct group_info *ginfo, __u32 *gids)
 149 {
 150         int i, ngroups = ginfo->ngroups;
 151
 152         for (i = 0; i < ginfo->nblocks; i++) {
 153                 int count = min(NGROUPS_PER_BLOCK, ngroups);
 154
 155                 memcpy(ginfo->blocks[i], gids, count * sizeof(__u32));
 156                 gids += NGROUPS_PER_BLOCK;
 157                 ngroups -= count;
 158         }
 159 }
 160
 161 void mds_pack_dentry2id(struct obd_device *obd,
 162                         struct lustre_id *id,
 163                         struct dentry *dentry,
 164                         int fid)
 165 {
 166         id_ino(id) = dentry->d_inum;
 167         id_gen(id) = dentry->d_generation;
 168
 169         if (fid) {
 170                 id_fid(id) = dentry->d_fid;
 171                 id_group(id) = dentry->d_mdsnum;
 172         }
 173 }
 174
 175 void mds_pack_dentry2body(struct obd_device *obd,
 176                           struct mds_body *b,
 177                           struct dentry *dentry,
 178                           int fid)
 179 {
 180         b->valid |= OBD_MD_FLID | OBD_MD_FLGENER |
 181                 OBD_MD_MDS;
 182
 183         if (fid)
 184                 b->valid |= OBD_MD_FID;
 185
 186         mds_pack_dentry2id(obd, &b->id1, dentry, fid);
 187 }
 188
 189 int mds_pack_inode2id(struct obd_device *obd,
 190                       struct lustre_id *id,
 191                       struct inode *inode,
 192                       int fid)
 193 {
 194         int rc = 0;
 195         ENTRY;
 196
 197         if (fid) {
 198                 /* we have to avoid deadlock. */
 199                 if (!down_trylock(&inode->i_sem)) {
 200                         rc = mds_read_inode_sid(obd, inode, id);
 201                         up(&inode->i_sem);
 202                 } else {
 203                         rc = mds_read_inode_sid(obd, inode, id);
 204                 }
 205         }
 206
 207         if (rc == 0) {
 208                 id_ino(id) = inode->i_ino;
 209                 id_gen(id) = inode->i_generation;
 210                 id_type(id) = (S_IFMT & inode->i_mode);
 211         }
 212         RETURN(rc);
 213 }
 214
 215 /* Note that we can copy all of the fields, just some will not be "valid" */
 216 void mds_pack_inode2body(struct obd_device *obd, struct mds_body *b,
 217                          struct inode *inode, int fid)
 218 {
 219         b->valid |= OBD_MD_FLID | OBD_MD_FLCTIME | OBD_MD_FLUID |
 220                 OBD_MD_FLGID | OBD_MD_FLFLAGS | OBD_MD_FLTYPE |
 221                 OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER |
 222                 OBD_MD_FLATIME | OBD_MD_FLMTIME; /* bug 2020 */
 223
 224         if (!S_ISREG(inode->i_mode)) {
 225                 b->valid |= OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
 226                         OBD_MD_FLATIME | OBD_MD_FLMTIME |
 227                         OBD_MD_FLRDEV;
 228         }
 229         b->atime = LTIME_S(inode->i_atime);
 230         b->mtime = LTIME_S(inode->i_mtime);
 231         b->ctime = LTIME_S(inode->i_ctime);
 232         b->mode = inode->i_mode;
 233         b->size = inode->i_size;
 234         b->blocks = inode->i_blocks;
 235         b->uid = inode->i_uid;
 236         b->gid = inode->i_gid;
 237         b->flags = inode->i_flags;
 238         b->rdev = inode->i_rdev;
 239
 240         /* Return the correct link count for orphan inodes */
 241         if (mds_inode_is_orphan(inode)) {
 242                 b->nlink = 0;
 243         } else if (S_ISDIR(inode->i_mode)) {
 244                 b->nlink = 1;
 245         } else {
 246                 b->nlink = inode->i_nlink;
 247         }
 248
 249         if (fid)
 250                 b->valid |= OBD_MD_FID;
 251
 252         mds_pack_inode2id(obd, &b->id1, inode, fid);
 253 }
 254
 255 /* unpacking */
 256 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 257                               struct mds_update_record *r)
 258 {
 259         struct iattr *attr = &r->ur_iattr;
 260         struct mds_rec_setattr *rec;
 261         ENTRY;
 262
 263         rec = lustre_swab_reqbuf(req, offset, sizeof(*rec),
 264                                  lustre_swab_mds_rec_setattr);
 265         if (rec == NULL)
 266                 RETURN (-EFAULT);
 267
 268         r->ur_id1 = &rec->sa_id;
 269         attr->ia_valid = rec->sa_valid;
 270         attr->ia_mode = rec->sa_mode;
 271         attr->ia_uid = rec->sa_uid;
 272         attr->ia_gid = rec->sa_gid;
 273         attr->ia_size = rec->sa_size;
 274         LTIME_S(attr->ia_atime) = rec->sa_atime;
 275         LTIME_S(attr->ia_mtime) = rec->sa_mtime;
 276         LTIME_S(attr->ia_ctime) = rec->sa_ctime;
 277         attr->ia_attr_flags = rec->sa_attr_flags;
 278
 279         LASSERT_REQSWAB (req, offset + 1);
 280         if (req->rq_reqmsg->bufcount > offset + 1) {
 281                 r->ur_eadata = lustre_msg_buf (req->rq_reqmsg,
 282                                                offset + 1, 0);
 283                 if (r->ur_eadata == NULL)
 284                         RETURN (-EFAULT);
 285                 r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 1];
 286         }
 287
 288         if (req->rq_reqmsg->bufcount > offset + 2) {
 289                 r->ur_ea2data = lustre_msg_buf(req->rq_reqmsg, offset + 2, 0);
 290                 if (r->ur_ea2data == NULL)
 291                         RETURN (-EFAULT);
 292
 293                 r->ur_ea2datalen = req->rq_reqmsg->buflens[offset + 2];
 294         }
 295
 296         RETURN(0);
 297 }
 298
 299 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 300                              struct mds_update_record *r)
 301 {
 302         struct mds_rec_create *rec;
 303         ENTRY;
 304
 305         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 306                                   lustre_swab_mds_rec_create);
 307         if (rec == NULL)
 308                 RETURN (-EFAULT);
 309
 310         r->ur_id1 = &rec->cr_id;
 311         r->ur_id2 = &rec->cr_replayid;
 312         r->ur_mode = rec->cr_mode;
 313         r->ur_rdev = rec->cr_rdev;
 314         r->ur_time = rec->cr_time;
 315         r->ur_flags = rec->cr_flags;
 316
 317         LASSERT_REQSWAB (req, offset + 1);
 318         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 319         if (r->ur_name == NULL)
 320                 RETURN (-EFAULT);
 321         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 322
 323         LASSERT_REQSWAB (req, offset + 2);
 324         if (req->rq_reqmsg->bufcount > offset + 2) {
 325                 if (S_ISLNK(r->ur_mode)) {
 326                         r->ur_tgt = lustre_msg_string(req->rq_reqmsg,
 327                                                       offset + 2, 0);
 328                         if (r->ur_tgt == NULL)
 329                                 RETURN (-EFAULT);
 330                         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 331                 } else if (S_ISDIR(r->ur_mode)) {
 332                         /* Stripe info for mkdir - just a 16bit integer */
 333                         if (req->rq_reqmsg->buflens[offset + 2] != 2) {
 334                                 CERROR("mkdir stripe info does not match "
 335                                        "expected size %d vs 2\n",
 336                                        req->rq_reqmsg->buflens[offset + 2]);
 337                                 RETURN (-EINVAL);
 338                         }
 339                         r->ur_eadata = lustre_swab_buf (req->rq_reqmsg,
 340                                                offset + 2, 2, __swab16s);
 341                         r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 2];
 342                 } else {
 343                         /* Hm, no other users so far? */
 344                         LBUG();
 345                 }
 346         }
 347         RETURN(0);
 348 }
 349
 350 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 351                            struct mds_update_record *r)
 352 {
 353         struct mds_rec_link *rec;
 354         ENTRY;
 355
 356         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 357                                   lustre_swab_mds_rec_link);
 358         if (rec == NULL)
 359                 RETURN (-EFAULT);
 360
 361         r->ur_id1 = &rec->lk_id1;
 362         r->ur_id2 = &rec->lk_id2;
 363         r->ur_time = rec->lk_time;
 364
 365         LASSERT_REQSWAB (req, offset + 1);
 366         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 367         if (r->ur_name == NULL)
 368                 RETURN (-EFAULT);
 369         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 370         RETURN(0);
 371 }
 372
 373 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 374                              struct mds_update_record *r)
 375 {
 376         struct mds_rec_unlink *rec;
 377         ENTRY;
 378
 379         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 380                                   lustre_swab_mds_rec_unlink);
 381         if (rec == NULL)
 382                 RETURN(-EFAULT);
 383
 384         r->ur_mode = rec->ul_mode;
 385         r->ur_id1 = &rec->ul_id1;
 386         r->ur_id2 = &rec->ul_id2;
 387         r->ur_time = rec->ul_time;
 388
 389         LASSERT_REQSWAB (req, offset + 1);
 390         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 391         if (r->ur_name == NULL)
 392                 RETURN(-EFAULT);
 393         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 394         RETURN(0);
 395 }
 396
 397 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 398                              struct mds_update_record *r)
 399 {
 400         struct mds_rec_rename *rec;
 401         ENTRY;
 402
 403         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 404                                   lustre_swab_mds_rec_rename);
 405         if (rec == NULL)
 406                 RETURN(-EFAULT);
 407
 408         r->ur_id1 = &rec->rn_id1;
 409         r->ur_id2 = &rec->rn_id2;
 410         r->ur_time = rec->rn_time;
 411
 412         LASSERT_REQSWAB (req, offset + 1);
 413         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 414         if (r->ur_name == NULL)
 415                 RETURN(-EFAULT);
 416         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 417
 418         LASSERT_REQSWAB (req, offset + 2);
 419         r->ur_tgt = lustre_msg_string(req->rq_reqmsg, offset + 2, 0);
 420         if (r->ur_tgt == NULL)
 421                 RETURN(-EFAULT);
 422         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 423         RETURN(0);
 424 }
 425
 426 static int mds_open_unpack(struct ptlrpc_request *req, int offset,
 427                            struct mds_update_record *r)
 428 {
 429         struct mds_rec_create *rec;
 430         ENTRY;
 431
 432         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 433                                   lustre_swab_mds_rec_create);
 434         if (rec == NULL)
 435                 RETURN(-EFAULT);
 436
 437         r->ur_id1 = &rec->cr_id;
 438         r->ur_id2 = &rec->cr_replayid;
 439         r->ur_mode = rec->cr_mode;
 440         r->ur_rdev = rec->cr_rdev;
 441         r->ur_time = rec->cr_time;
 442         r->ur_flags = rec->cr_flags;
 443
 444         LASSERT_REQSWAB (req, offset + 1);
 445         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 446         if (r->ur_name == NULL)
 447                 RETURN (-EFAULT);
 448         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 449
 450         LASSERT_REQSWAB (req, offset + 2);
 451         if (req->rq_reqmsg->bufcount > offset + 2) {
 452                 r->ur_eadata = lustre_msg_buf(req->rq_reqmsg, offset + 2, 0);
 453                 if (r->ur_eadata == NULL)
 454                         RETURN(-EFAULT);
 455                 r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 2];
 456         }
 457         RETURN(0);
 458 }
 459
 460 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 461                                struct mds_update_record *r);
 462
 463 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 464         [REINT_SETATTR] mds_setattr_unpack,
 465         [REINT_CREATE] mds_create_unpack,
 466         [REINT_LINK] mds_link_unpack,
 467         [REINT_UNLINK] mds_unlink_unpack,
 468         [REINT_RENAME] mds_rename_unpack,
 469         [REINT_OPEN] mds_open_unpack,
 470 };
 471
 472 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 473                       struct mds_update_record *rec)
 474 {
 475         __u32 *opcodep;
 476         __u32  opcode;
 477         int rc;
 478         ENTRY;
 479
 480         /*
 481          * NB don't lustre_swab_reqbuf() here. We're just taking a peek and we
 482          * want to leave it to the specific unpacker once we've identified the
 483          * message type.
 484          */
 485         opcodep = lustre_msg_buf (req->rq_reqmsg, offset, sizeof(*opcodep));
 486         if (opcodep == NULL)
 487                 RETURN(-EFAULT);
 488
 489         opcode = *opcodep;
 490         if (lustre_msg_swabbed (req->rq_reqmsg))
 491                 __swab32s (&opcode);
 492
 493         if (opcode > REINT_MAX ||
 494             mds_unpackers[opcode] == NULL) {
 495                 CERROR ("Unexpected opcode %d\n", opcode);
 496                 RETURN(-EFAULT);
 497         }
 498
 499         rec->ur_id1 = NULL;
 500         rec->ur_id2 = NULL;
 501         rec->ur_opcode = opcode;
 502
 503         rc = mds_unpackers[opcode](req, offset, rec);
 504
 505 #if CRAY_PORTALS
 506         rec->ur_fsuid = req->rq_uid;
 507 #endif
 508         RETURN(rc);
 509 }
 510
 511 static
 512 struct mds_idmap_table *__get_idmap_table(struct mds_export_data *med,
 513                                           int create)
 514 {
 515         struct mds_idmap_table *new;
 516         int i;
 517
 518         if (!create || med->med_idmap)
 519                 return med->med_idmap;
 520
 521         spin_unlock(&med->med_idmap_lock);
 522         OBD_ALLOC(new, sizeof(*new));
 523         spin_lock(&med->med_idmap_lock);
 524
 525         if (!new) {
 526                 CERROR("fail to alloc %d\n", sizeof(*new));
 527                 return NULL;
 528         }
 529
 530         if (med->med_idmap) {
 531                 OBD_FREE(new, sizeof(*new));
 532                 return med->med_idmap;
 533         }
 534
 535         for (i = 0; i < MDS_IDMAP_HASHSIZE; i++) {
 536                 INIT_LIST_HEAD(&new->uidmap[i]);
 537                 INIT_LIST_HEAD(&new->gidmap[i]);
 538         }
 539
 540         CDEBUG(D_SEC, "allocate idmap table for med %p\n", med);
 541         med->med_idmap = new;
 542         return new;
 543 }
 544
 545 static void __flush_mapping_table(struct list_head *table)
 546 {
 547         struct mds_idmap_item *item;
 548         int i;
 549
 550         for (i = 0; i < MDS_IDMAP_HASHSIZE; i++) {
 551                 while (!list_empty(&table[i])) {
 552                         item = list_entry(table[i].next, struct mds_idmap_item,
 553                                           hash);
 554                         list_del(&item->hash);
 555                         OBD_FREE(item, sizeof(*item));
 556                 }
 557         }
 558 }
 559
 560 void mds_idmap_cleanup(struct mds_export_data *med)
 561 {
 562         ENTRY;
 563
 564         if (!med->med_idmap) {
 565                 EXIT;
 566                 return;
 567         }
 568
 569         spin_lock(&med->med_idmap_lock);
 570         __flush_mapping_table(med->med_idmap->uidmap);
 571         __flush_mapping_table(med->med_idmap->gidmap);
 572         OBD_FREE(med->med_idmap, sizeof(struct mds_idmap_table));
 573         spin_unlock(&med->med_idmap_lock);
 574 }
 575
 576 static inline int idmap_hash(__u32 id)
 577 {
 578         return (id & (MDS_IDMAP_HASHSIZE - 1));
 579 }
 580
 581 static
 582 int __idmap_set_item(struct mds_export_data *med,
 583                      struct list_head *table,
 584                      __u32 id1, __u32 id2)
 585 {
 586         struct list_head *head;
 587         struct mds_idmap_item *item, *new = NULL;
 588         int found = 0;
 589
 590         head = table + idmap_hash(id1);
 591 again:
 592         list_for_each_entry(item, head, hash) {
 593                 if (item->id1 == id1) {
 594                         found = 1;
 595                         break;
 596                 }
 597         }
 598
 599         if (!found) {
 600                 if (new == NULL) {
 601                         spin_unlock(&med->med_idmap_lock);
 602                         OBD_ALLOC(new, sizeof(*new));
 603                         spin_lock(&med->med_idmap_lock);
 604                         if (!new) {
 605                                 CERROR("fail to alloc %d\n", sizeof(*new));
 606                                 return -ENOMEM;
 607                         }
 608                         goto again;
 609                 }
 610                 new->id1 = id1;
 611                 new->id2 = id2;
 612                 list_add(&new->hash, head);
 613         } else {
 614                 if (new)
 615                         OBD_FREE(new, sizeof(*new));
 616                 if (item->id2 != id2) {
 617                         CWARN("mapping changed: %u ==> (%u -> %u)\n",
 618                                id1, item->id2, id2);
 619                         item->id2 = id2;
 620                 }
 621                 list_move(&item->hash, head);
 622         }
 623
 624         return 0;
 625 }
 626
 627 int mds_idmap_set(struct mds_export_data *med, __u32 id1, __u32 id2,
 628                   int is_uid_mapping)
 629 {
 630         struct mds_idmap_table *idmap;
 631         int rc;
 632         ENTRY;
 633
 634         spin_lock(&med->med_idmap_lock);
 635
 636         idmap = __get_idmap_table(med, 1);
 637         if (!idmap)
 638                 GOTO(out, rc = -ENOMEM);
 639
 640         if (is_uid_mapping)
 641                 rc = __idmap_set_item(med, idmap->uidmap, id1, id2);
 642         else
 643                 rc = __idmap_set_item(med, idmap->gidmap, id1, id2);
 644
 645 out:
 646         spin_unlock(&med->med_idmap_lock);
 647         RETURN(rc);
 648 }
 649
 650 __u32 mds_idmap_get(struct mds_export_data *med, __u32 id,
 651                     int is_uid_mapping)
 652 {
 653         struct mds_idmap_table *idmap;
 654         struct list_head *table;
 655         struct list_head *head;
 656         struct mds_idmap_item *item;
 657         int found = 0;
 658         __u32 res;
 659
 660         spin_lock(&med->med_idmap_lock);
 661         idmap = __get_idmap_table(med, 0);
 662         if (!idmap)
 663                 goto nllu;
 664
 665         table = is_uid_mapping ? idmap->uidmap : idmap->gidmap;
 666         head = table + idmap_hash(id);
 667
 668         list_for_each_entry(item, head, hash) {
 669                 if (item->id1 == id) {
 670                         found = 1;
 671                         break;
 672                 }
 673         }
 674         if (!found)
 675                 goto nllu;
 676
 677         res = item->id2;
 678 out:
 679         spin_unlock(&med->med_idmap_lock);
 680         return res;
 681 nllu:
 682         res = is_uid_mapping ? med->med_nllu : med->med_nllg;
 683         goto out;
 684 }
 685
 686 void mds_reverse_map_ugid(struct ptlrpc_request *req,
 687                           struct mds_body *body)
 688 {
 689         struct mds_export_data *med = &req->rq_export->u.eu_mds_data;
 690
 691         LASSERT(req->rq_remote);
 692
 693         if (body->valid & OBD_MD_FLUID)
 694                 body->uid = mds_idmap_get(med, body->uid, 1);
 695
 696         if (body->valid & OBD_MD_FLGID)
 697                 body->gid = mds_idmap_get(med, body->gid, 0);
 698 }
 699
 700 static inline void drop_ucred_ginfo(struct lvfs_ucred *ucred)
 701 {
 702         if (ucred->luc_ginfo) {
 703                 put_group_info(ucred->luc_ginfo);
 704                 ucred->luc_ginfo = NULL;
 705         }
 706 }
 707
 708 static inline void drop_ucred_lsd(struct lvfs_ucred *ucred)
 709 {
 710         if (ucred->luc_lsd) {
 711                 mds_put_lsd(ucred->luc_lsd);
 712                 ucred->luc_lsd = NULL;
 713         }
 714 }
 715
 716 /*
 717  * the heart of the uid/gid handling and security checking.
 718  *
 719  * root could set any group_info if we allowed setgroups, while
 720  * normal user only could 'reduce' their group members -- which
 721  * is somewhat expensive.
 722  */
 723 int mds_init_ucred(struct lvfs_ucred *ucred,
 724                    struct ptlrpc_request *req,
 725                    struct mds_req_sec_desc *rsd)
 726 {
 727         struct mds_obd *mds = &req->rq_export->exp_obd->u.mds;
 728         struct mds_export_data *med = &req->rq_export->u.eu_mds_data;
 729         struct lustre_sec_desc *lsd;
 730         ptl_nid_t peernid = req->rq_peer.peer_id.nid;
 731         struct group_info *gnew;
 732         unsigned int setuid, setgid, strong_sec;
 733         ENTRY;
 734
 735         LASSERT(ucred);
 736         LASSERT(rsd);
 737         LASSERT(rsd->rsd_ngroups <= LUSTRE_MAX_GROUPS);
 738
 739         strong_sec = (req->rq_auth_uid != -1);
 740         LASSERT(!(req->rq_remote && !strong_sec));
 741
 742         /* sanity check & set local/remote flag */
 743         if (req->rq_remote) {
 744                 if (med->med_local) {
 745                         CWARN("exp %p: client on nid "LPX64" was local, "
 746                               "set to remote\n", req->rq_export, peernid);
 747                         med->med_local = 0;
 748                 }
 749         } else {
 750                 if (!med->med_local) {
 751                         CWARN("exp %p: client on nid "LPX64" was remote, "
 752                               "set to local\n", req->rq_export, peernid);
 753                         med->med_local = 1;
 754                 }
 755         }
 756
 757         setuid = (rsd->rsd_fsuid != rsd->rsd_uid);
 758         setgid = (rsd->rsd_fsgid != rsd->rsd_gid);
 759
 760         /* deny setuid/setgid for remote client */
 761         if ((setuid || setgid) && !med->med_local) {
 762                 CWARN("deny setxid (%u/%u) from remote client "LPX64"\n",
 763                       setuid, setgid, peernid);
 764                 RETURN(-EPERM);
 765         }
 766
 767         /* take care of uid/gid mapping for client in remote realm */
 768         if (req->rq_remote) {
 769                 /* record the uid mapping here */
 770                 mds_idmap_set(med, req->rq_auth_uid, rsd->rsd_uid, 1);
 771
 772                 /* now we act as the authenticated user */
 773                 rsd->rsd_uid = rsd->rsd_fsuid = req->rq_auth_uid;
 774         } else if (strong_sec && req->rq_auth_uid != rsd->rsd_uid) {
 775                 /* if we use strong authentication on this request, we
 776                  * expect the uid which client claimed is true.
 777                  *
 778                  * FIXME root's machine_credential in krb5 will be interpret
 779                  * as "nobody", which is not good for mds-mds and mds-ost
 780                  * connection.
 781                  */
 782                 CWARN("nid "LPX64": UID %u was authenticated while client "
 783                       "claimed %u, set %u by force\n",
 784                       peernid, req->rq_auth_uid, rsd->rsd_uid,
 785                       req->rq_auth_uid);
 786                 rsd->rsd_uid = req->rq_auth_uid;
 787         }
 788
 789         /* now lsd come into play */
 790         ucred->luc_ginfo = NULL;
 791         ucred->luc_lsd = lsd = mds_get_lsd(rsd->rsd_uid);
 792
 793 #if CRAY_PORTALS
 794         ucred->luc_fsuid = req->rq_uid;
 795 #else
 796         ucred->luc_fsuid = rsd->rsd_fsuid;
 797 #endif
 798         if (lsd) {
 799                 if (req->rq_remote) {
 800                         /* record the gid mapping here */
 801                         mds_idmap_set(med, lsd->lsd_gid, rsd->rsd_gid, 0);
 802                         /* now we act as the authenticated group */
 803                         rsd->rsd_gid = rsd->rsd_fsgid = lsd->lsd_gid;
 804                 } else if (rsd->rsd_gid != lsd->lsd_gid) {
 805                         /* verify gid which client declared is true */
 806                         CWARN("GID: %u while client declare %u, "
 807                               "set %u by force\n",
 808                               lsd->lsd_gid, rsd->rsd_gid,
 809                               lsd->lsd_gid);
 810                         rsd->rsd_gid = lsd->lsd_gid;
 811                 }
 812
 813                 if (lsd->lsd_ginfo) {
 814                         ucred->luc_ginfo = lsd->lsd_ginfo;
 815                         get_group_info(ucred->luc_ginfo);
 816                 }
 817
 818                 /* check permission of setuid */
 819                 if (setuid) {
 820                         if (!lsd->lsd_allow_setuid) {
 821                                 CWARN("mds blocked setuid attempt: %u -> %u\n",
 822                                       rsd->rsd_uid, rsd->rsd_fsuid);
 823                                 RETURN(-EPERM);
 824                         }
 825                 }
 826
 827                 /* check permission of setgid */
 828                 if (setgid) {
 829                         if (!lsd->lsd_allow_setgid) {
 830                                 CWARN("mds blocked setgid attempt: %u -> %u\n",
 831                                       rsd->rsd_gid, rsd->rsd_fsgid);
 832                                 RETURN(-EPERM);
 833                         }
 834                 }
 835         } else {
 836                 /* failed to get lsd, right now we simply deny any access
 837                  * if strong authentication is used,
 838                  */
 839                 if (strong_sec) {
 840                         CWARN("mds deny access without LSD\n");
 841                         RETURN(-EPERM);
 842                 }
 843
 844                 /* and otherwise deny setuid/setgid attempt */
 845                 if (setuid || setgid) {
 846                         CWARN("mds deny setuid/setgid without LSD\n");
 847                         RETURN(-EPERM);
 848                 }
 849         }
 850
 851         /* NOTE: we have already obtained supplementary groups,
 852          * it will be retained across root_squash. will it be a
 853          * security problem??
 854          */
 855         mds_squash_root(mds, rsd, &peernid);
 856
 857         /* remove privilege for non-root user */
 858         if (rsd->rsd_fsuid)
 859                 rsd->rsd_cap &= ~CAP_FS_MASK;
 860
 861         /* by now every fields in rsd have been granted */
 862         ucred->luc_fsgid = rsd->rsd_fsgid;
 863         ucred->luc_cap = rsd->rsd_cap;
 864         ucred->luc_uid = rsd->rsd_uid;
 865
 866         /* everything is done if we don't allow setgroups */
 867         if (!lsd || !lsd->lsd_allow_setgrp)
 868                 RETURN(0);
 869
 870         if (ucred->luc_uid == 0) {
 871                 if (rsd->rsd_ngroups == 0) {
 872                         drop_ucred_ginfo(ucred);
 873                         RETURN(0);
 874                 }
 875
 876                 gnew = groups_alloc(rsd->rsd_ngroups);
 877                 if (!gnew) {
 878                         CERROR("out of memory\n");
 879                         drop_ucred_ginfo(ucred);
 880                         drop_ucred_lsd(ucred);
 881                         RETURN(-ENOMEM);
 882                 }
 883                 groups_from_buffer(gnew, rsd->rsd_groups);
 884                 groups_sort(gnew); /* can't rely on client */
 885
 886                 drop_ucred_ginfo(ucred);
 887                 ucred->luc_ginfo = gnew;
 888         } else {
 889                 __u32 set = 0, cur = 0;
 890                 struct group_info *ginfo;
 891
 892                 /* if no group info in hash, we don't
 893                  * bother createing new
 894                  */
 895                 if (!ucred->luc_ginfo)
 896                         RETURN(0);
 897
 898                 /* Note: freeing a group_info count on 'nblocks' instead of
 899                  * 'ngroups', thus we can safely alloc enough buffer and reduce
 900                  * and ngroups number later.
 901                  */
 902                 gnew = groups_alloc(rsd->rsd_ngroups);
 903                 if (!gnew) {
 904                         CERROR("out of memory\n");
 905                         drop_ucred_ginfo(ucred);
 906                         drop_ucred_lsd(ucred);
 907                         RETURN(-ENOMEM);
 908                 }
 909
 910                 ginfo = ucred->luc_ginfo;
 911                 while (cur < rsd->rsd_ngroups) {
 912                         if (groups_search(ginfo, rsd->rsd_groups[cur])) {
 913                                 GROUP_AT(gnew, set) = rsd->rsd_groups[cur];
 914                                 set++;
 915                         }
 916                         cur++;
 917                 }
 918                 gnew->ngroups = set;
 919
 920                 put_group_info(ucred->luc_ginfo);
 921                 ucred->luc_ginfo = gnew;
 922         }
 923         RETURN(0);
 924 }
 925
 926 void mds_exit_ucred(struct lvfs_ucred *ucred)
 927 {
 928         ENTRY;
 929         drop_ucred_ginfo(ucred);
 930         drop_ucred_lsd(ucred);
 931         EXIT;
 932 }