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 #include "mds_internal.h"
  53
  54 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,4)
  55 struct group_info *groups_alloc(int ngroups)
  56 {
  57         struct group_info *ginfo;
  58
  59         LASSERT(ngroups <= NGROUPS_SMALL);
  60
  61         OBD_ALLOC(ginfo, sizeof(*ginfo) + 1 * sizeof(gid_t *));
  62         if (!ginfo)
  63                 return NULL;
  64         ginfo->ngroups = ngroups;
  65         ginfo->nblocks = 1;
  66         ginfo->blocks[0] = ginfo->small_block;
  67         atomic_set(&ginfo->usage, 1);
  68
  69         return ginfo;
  70 }
  71
  72 void groups_free(struct group_info *ginfo)
  73 {
  74         LASSERT(ginfo->ngroups <= NGROUPS_SMALL);
  75         LASSERT(ginfo->nblocks == 1);
  76         LASSERT(ginfo->blocks[0] == ginfo->small_block);
  77
  78         OBD_FREE(ginfo, sizeof(*ginfo) + 1 * sizeof(gid_t *));
  79 }
  80
  81 /* for 2.4 the group number is small, so simply search the
  82  * whole array.
  83  */
  84 int groups_search(struct group_info *ginfo, gid_t grp)
  85 {
  86         int i;
  87
  88         if (!ginfo)
  89                 return 0;
  90
  91         for (i = 0; i < ginfo->ngroups; i++)
  92                 if (GROUP_AT(ginfo, i) == grp)
  93                         return 1;
  94         return 0;
  95 }
  96
  97 #else /* >= 2.6.4 */
  98
  99 void groups_sort(struct group_info *ginfo)
 100 {
 101         int base, max, stride;
 102         int gidsetsize = ginfo->ngroups;
 103
 104         for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
 105                 ; /* nothing */
 106         stride /= 3;
 107
 108         while (stride) {
 109                 max = gidsetsize - stride;
 110                 for (base = 0; base < max; base++) {
 111                         int left = base;
 112                         int right = left + stride;
 113                         gid_t tmp = GROUP_AT(ginfo, right);
 114
 115                         while (left >= 0 && GROUP_AT(ginfo, left) > tmp) {
 116                                 GROUP_AT(ginfo, right) =
 117                                     GROUP_AT(ginfo, left);
 118                                 right = left;
 119                                 left -= stride;
 120                         }
 121                         GROUP_AT(ginfo, right) = tmp;
 122                 }
 123                 stride /= 3;
 124         }
 125 }
 126
 127 int groups_search(struct group_info *ginfo, gid_t grp)
 128 {
 129         int left, right;
 130
 131         if (!ginfo)
 132                 return 0;
 133
 134         left = 0;
 135         right = ginfo->ngroups;
 136         while (left < right) {
 137                 int mid = (left + right) / 2;
 138                 int cmp = grp - GROUP_AT(ginfo, mid);
 139                 if (cmp > 0)
 140                         left = mid + 1;
 141                 else if (cmp < 0)
 142                         right = mid;
 143                 else
 144                         return 1;
 145         }
 146         return 0;
 147 }
 148
 149 #endif
 150
 151 void groups_from_buffer(struct group_info *ginfo, __u32 *gids)
 152 {
 153         int i, ngroups = ginfo->ngroups;
 154
 155         for (i = 0; i < ginfo->nblocks; i++) {
 156                 int count = min(NGROUPS_PER_BLOCK, ngroups);
 157
 158                 memcpy(ginfo->blocks[i], gids, count * sizeof(__u32));
 159                 gids += NGROUPS_PER_BLOCK;
 160                 ngroups -= count;
 161         }
 162 }
 163
 164 void mds_pack_dentry2fid(struct ll_fid *fid, struct dentry *dentry)
 165 {
 166         fid->id = dentry->d_inum;
 167         fid->generation = dentry->d_generation;
 168         fid->mds = dentry->d_mdsnum;
 169 }
 170
 171 void mds_pack_dentry2body(struct mds_body *b, struct dentry *dentry)
 172 {
 173         b->valid |= OBD_MD_FLID | OBD_MD_FLGENER;
 174         b->ino = dentry->d_inum;
 175         b->generation = dentry->d_generation;
 176         b->mds = dentry->d_mdsnum;
 177 }
 178
 179 void mds_pack_inode2fid(struct obd_device *obd, struct ll_fid *fid,
 180                                 struct inode *inode)
 181 {
 182         if (!obd || !fid || !inode) {
 183                 printk("obd %p, fid %p, inode %p\n", obd, fid, inode);
 184                 LBUG();
 185         }
 186         fid->id = inode->i_ino;
 187         fid->generation = inode->i_generation;
 188         fid->f_type = (S_IFMT & inode->i_mode);
 189         fid->mds = obd->u.mds.mds_num;
 190 }
 191
 192 /* Note that we can copy all of the fields, just some will not be "valid" */
 193 void mds_pack_inode2body(struct obd_device *obd, struct mds_body *b,
 194                                 struct inode *inode)
 195 {
 196         b->valid |= OBD_MD_FLID | OBD_MD_FLCTIME | OBD_MD_FLUID |
 197                     OBD_MD_FLGID | OBD_MD_FLFLAGS | OBD_MD_FLTYPE |
 198                     OBD_MD_FLMODE | OBD_MD_FLNLINK | OBD_MD_FLGENER |
 199                     OBD_MD_FLATIME | OBD_MD_FLMTIME; /* bug 2020 */
 200
 201         if (!S_ISREG(inode->i_mode))
 202                 b->valid |= OBD_MD_FLSIZE | OBD_MD_FLBLOCKS | OBD_MD_FLATIME |
 203                             OBD_MD_FLMTIME | OBD_MD_FLRDEV;
 204
 205         b->ino = inode->i_ino;
 206         b->atime = LTIME_S(inode->i_atime);
 207         b->mtime = LTIME_S(inode->i_mtime);
 208         b->ctime = LTIME_S(inode->i_ctime);
 209         b->mode = inode->i_mode;
 210         b->size = inode->i_size;
 211         b->blocks = inode->i_blocks;
 212         b->uid = inode->i_uid;
 213         b->gid = inode->i_gid;
 214         b->flags = inode->i_flags;
 215         b->rdev = inode->i_rdev;
 216         /* Return the correct link count for orphan inodes */
 217         if (mds_inode_is_orphan(inode)) {
 218                 b->nlink = 0;
 219         } else if (S_ISDIR(inode->i_mode)) {
 220                 b->nlink = 1;
 221         } else {
 222                 b->nlink = inode->i_nlink;
 223         }
 224         b->generation = inode->i_generation;
 225         b->mds = obd->u.mds.mds_num;
 226 }
 227
 228 /* unpacking */
 229 static int mds_setattr_unpack(struct ptlrpc_request *req, int offset,
 230                               struct mds_update_record *r)
 231 {
 232         struct iattr *attr = &r->ur_iattr;
 233         struct mds_rec_setattr *rec;
 234         ENTRY;
 235
 236         rec = lustre_swab_reqbuf(req, offset, sizeof(*rec),
 237                                  lustre_swab_mds_rec_setattr);
 238         if (rec == NULL)
 239                 RETURN (-EFAULT);
 240
 241         r->ur_fid1 = &rec->sa_fid;
 242         attr->ia_valid = rec->sa_valid;
 243         attr->ia_mode = rec->sa_mode;
 244         attr->ia_uid = rec->sa_uid;
 245         attr->ia_gid = rec->sa_gid;
 246         attr->ia_size = rec->sa_size;
 247         LTIME_S(attr->ia_atime) = rec->sa_atime;
 248         LTIME_S(attr->ia_mtime) = rec->sa_mtime;
 249         LTIME_S(attr->ia_ctime) = rec->sa_ctime;
 250         attr->ia_attr_flags = rec->sa_attr_flags;
 251
 252         LASSERT_REQSWAB (req, offset + 1);
 253         if (req->rq_reqmsg->bufcount > offset + 1) {
 254                 r->ur_eadata = lustre_msg_buf (req->rq_reqmsg,
 255                                                offset + 1, 0);
 256                 if (r->ur_eadata == NULL)
 257                         RETURN (-EFAULT);
 258                 r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 1];
 259         }
 260
 261         if (req->rq_reqmsg->bufcount > offset + 2) {
 262                 r->ur_logcookies = lustre_msg_buf(req->rq_reqmsg, offset + 2,0);
 263                 if (r->ur_eadata == NULL)
 264                         RETURN (-EFAULT);
 265
 266                 r->ur_cookielen = req->rq_reqmsg->buflens[offset + 2];
 267         }
 268
 269         RETURN(0);
 270 }
 271
 272 static int mds_create_unpack(struct ptlrpc_request *req, int offset,
 273                              struct mds_update_record *r)
 274 {
 275         struct mds_rec_create *rec;
 276         ENTRY;
 277
 278         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 279                                   lustre_swab_mds_rec_create);
 280         if (rec == NULL)
 281                 RETURN (-EFAULT);
 282
 283         r->ur_fid1 = &rec->cr_fid;
 284         r->ur_fid2 = &rec->cr_replayfid;
 285         r->ur_mode = rec->cr_mode;
 286         r->ur_rdev = rec->cr_rdev;
 287         r->ur_time = rec->cr_time;
 288         r->ur_flags = rec->cr_flags;
 289
 290         LASSERT_REQSWAB (req, offset + 1);
 291         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 292         if (r->ur_name == NULL)
 293                 RETURN (-EFAULT);
 294         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 295
 296         LASSERT_REQSWAB (req, offset + 2);
 297         if (req->rq_reqmsg->bufcount > offset + 2) {
 298                 if (S_ISLNK(r->ur_mode)) {
 299                         r->ur_tgt = lustre_msg_string(req->rq_reqmsg,
 300                                                       offset + 2, 0);
 301                         if (r->ur_tgt == NULL)
 302                                 RETURN (-EFAULT);
 303                         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 304                 } else if (S_ISDIR(r->ur_mode)) {
 305                         /* Stripe info for mkdir - just a 16bit integer */
 306                         if (req->rq_reqmsg->buflens[offset + 2] != 2) {
 307                                 CERROR("mkdir stripe info does not match "
 308                                        "expected size %d vs 2\n",
 309                                        req->rq_reqmsg->buflens[offset + 2]);
 310                                 RETURN (-EINVAL);
 311                         }
 312                         r->ur_eadata = lustre_swab_buf (req->rq_reqmsg,
 313                                                offset + 2, 2, __swab16s);
 314                         r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 2];
 315                 } else {
 316                         /* Hm, no other users so far? */
 317                         LBUG();
 318                 }
 319         }
 320         RETURN(0);
 321 }
 322
 323 static int mds_link_unpack(struct ptlrpc_request *req, int offset,
 324                            struct mds_update_record *r)
 325 {
 326         struct mds_rec_link *rec;
 327         ENTRY;
 328
 329         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 330                                   lustre_swab_mds_rec_link);
 331         if (rec == NULL)
 332                 RETURN (-EFAULT);
 333
 334         r->ur_fid1 = &rec->lk_fid1;
 335         r->ur_fid2 = &rec->lk_fid2;
 336         r->ur_time = rec->lk_time;
 337
 338         LASSERT_REQSWAB (req, offset + 1);
 339         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 340         if (r->ur_name == NULL)
 341                 RETURN (-EFAULT);
 342         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 343         RETURN(0);
 344 }
 345
 346 static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
 347                              struct mds_update_record *r)
 348 {
 349         struct mds_rec_unlink *rec;
 350         ENTRY;
 351
 352         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 353                                   lustre_swab_mds_rec_unlink);
 354         if (rec == NULL)
 355                 RETURN(-EFAULT);
 356
 357         r->ur_mode = rec->ul_mode;
 358         r->ur_fid1 = &rec->ul_fid1;
 359         r->ur_fid2 = &rec->ul_fid2;
 360         r->ur_time = rec->ul_time;
 361
 362         LASSERT_REQSWAB (req, offset + 1);
 363         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 364         if (r->ur_name == NULL)
 365                 RETURN(-EFAULT);
 366         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 367         RETURN(0);
 368 }
 369
 370 static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
 371                              struct mds_update_record *r)
 372 {
 373         struct mds_rec_rename *rec;
 374         ENTRY;
 375
 376         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 377                                   lustre_swab_mds_rec_rename);
 378         if (rec == NULL)
 379                 RETURN(-EFAULT);
 380
 381         r->ur_fid1 = &rec->rn_fid1;
 382         r->ur_fid2 = &rec->rn_fid2;
 383         r->ur_time = rec->rn_time;
 384
 385         LASSERT_REQSWAB (req, offset + 1);
 386         r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
 387         if (r->ur_name == NULL)
 388                 RETURN(-EFAULT);
 389         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 390
 391         LASSERT_REQSWAB (req, offset + 2);
 392         r->ur_tgt = lustre_msg_string(req->rq_reqmsg, offset + 2, 0);
 393         if (r->ur_tgt == NULL)
 394                 RETURN(-EFAULT);
 395         r->ur_tgtlen = req->rq_reqmsg->buflens[offset + 2];
 396         RETURN(0);
 397 }
 398
 399 static int mds_open_unpack(struct ptlrpc_request *req, int offset,
 400                            struct mds_update_record *r)
 401 {
 402         struct mds_rec_create *rec;
 403         ENTRY;
 404
 405         rec = lustre_swab_reqbuf (req, offset, sizeof (*rec),
 406                                   lustre_swab_mds_rec_create);
 407         if (rec == NULL)
 408                 RETURN (-EFAULT);
 409
 410         r->ur_fid1 = &rec->cr_fid;
 411         r->ur_fid2 = &rec->cr_replayfid;
 412         r->ur_mode = rec->cr_mode;
 413         r->ur_rdev = rec->cr_rdev;
 414         r->ur_time = rec->cr_time;
 415         r->ur_flags = rec->cr_flags;
 416
 417         LASSERT_REQSWAB (req, offset + 1);
 418         r->ur_name = lustre_msg_string (req->rq_reqmsg, offset + 1, 0);
 419         if (r->ur_name == NULL)
 420                 RETURN (-EFAULT);
 421         r->ur_namelen = req->rq_reqmsg->buflens[offset + 1];
 422
 423         LASSERT_REQSWAB (req, offset + 2);
 424         if (req->rq_reqmsg->bufcount > offset + 2) {
 425                 r->ur_eadata = lustre_msg_buf(req->rq_reqmsg, offset + 2, 0);
 426                 if (r->ur_eadata == NULL)
 427                         RETURN (-EFAULT);
 428                 r->ur_eadatalen = req->rq_reqmsg->buflens[offset + 2];
 429         }
 430         RETURN(0);
 431 }
 432
 433 typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
 434                                struct mds_update_record *r);
 435
 436 static update_unpacker mds_unpackers[REINT_MAX + 1] = {
 437         [REINT_SETATTR] mds_setattr_unpack,
 438         [REINT_CREATE] mds_create_unpack,
 439         [REINT_LINK] mds_link_unpack,
 440         [REINT_UNLINK] mds_unlink_unpack,
 441         [REINT_RENAME] mds_rename_unpack,
 442         [REINT_OPEN] mds_open_unpack,
 443 };
 444
 445 int mds_update_unpack(struct ptlrpc_request *req, int offset,
 446                       struct mds_update_record *rec)
 447 {
 448         __u32 *opcodep;
 449         __u32  opcode;
 450         int rc;
 451         ENTRY;
 452
 453         /* NB don't lustre_swab_reqbuf() here.  We're just taking a peek
 454          * and we want to leave it to the specific unpacker once we've
 455          * identified the message type */
 456         opcodep = lustre_msg_buf (req->rq_reqmsg, offset, sizeof (*opcodep));
 457         if (opcodep == NULL)
 458                 RETURN(-EFAULT);
 459
 460         opcode = *opcodep;
 461         if (lustre_msg_swabbed (req->rq_reqmsg))
 462                 __swab32s (&opcode);
 463
 464         if (opcode > REINT_MAX ||
 465             mds_unpackers[opcode] == NULL) {
 466                 CERROR ("Unexpected opcode %d\n", opcode);
 467                 RETURN(-EFAULT);
 468         }
 469
 470         rec->ur_opcode = opcode;
 471         rc = mds_unpackers[opcode](req, offset, rec);
 472         RETURN(rc);
 473 }
 474
 475 static inline void drop_ucred_ginfo(struct lvfs_ucred *ucred)
 476 {
 477         if (ucred->luc_ginfo) {
 478                 put_group_info(ucred->luc_ginfo);
 479                 ucred->luc_ginfo = NULL;
 480         }
 481 }
 482
 483 /*
 484  * root could set any group_info if we allowed setgroups, while
 485  * normal user only could 'reduce' their group members -- which
 486  * is somewhat expensive.
 487  */
 488 int mds_init_ucred(struct lvfs_ucred *ucred, struct mds_req_sec_desc *rsd)
 489 {
 490         struct group_info *gnew;
 491
 492         ENTRY;
 493         LASSERT(ucred);
 494         LASSERT(rsd);
 495
 496         ucred->luc_fsuid = rsd->rsd_fsuid;
 497         ucred->luc_fsgid = rsd->rsd_fsgid;
 498         ucred->luc_cap = rsd->rsd_cap;
 499         ucred->luc_uid = rsd->rsd_uid;
 500         ucred->luc_ghash = mds_get_group_entry(NULL, rsd->rsd_uid);
 501         ucred->luc_ginfo = NULL;
 502
 503         if (ucred->luc_ghash && ucred->luc_ghash->ge_group_info) {
 504                 ucred->luc_ginfo = ucred->luc_ghash->ge_group_info;
 505                 get_group_info(ucred->luc_ginfo);
 506         }
 507
 508         /* everything is done if we don't allow setgroups */
 509         if (!mds_allow_setgroups())
 510                 RETURN(0);
 511
 512         if (rsd->rsd_ngroups > LUSTRE_MAX_GROUPS) {
 513                 CERROR("client provide too many groups: %d\n",
 514                 rsd->rsd_ngroups);
 515                 drop_ucred_ginfo(ucred);
 516                 mds_put_group_entry(NULL, ucred->luc_ghash);
 517                 RETURN(-EFAULT);
 518         }
 519
 520         if (ucred->luc_uid == 0) {
 521                 if (rsd->rsd_ngroups == 0) {
 522                         drop_ucred_ginfo(ucred);
 523                         RETURN(0);
 524                 }
 525
 526                 gnew = groups_alloc(rsd->rsd_ngroups);
 527                 if (!gnew) {
 528                         CERROR("out of memory\n");
 529                         drop_ucred_ginfo(ucred);
 530                         mds_put_group_entry(NULL, ucred->luc_ghash);
 531                         RETURN(-ENOMEM);
 532                 }
 533                 groups_from_buffer(gnew, rsd->rsd_groups);
 534                 /* can't rely on client to sort them */
 535                 groups_sort(gnew);
 536
 537                 drop_ucred_ginfo(ucred);
 538                 ucred->luc_ginfo = gnew;
 539         } else {
 540                 struct group_info *ginfo;
 541                 __u32 set = 0, cur = 0;
 542
 543                 /* if no group info in hash, we don't
 544                  * bother createing new
 545                  */
 546                 if (!ucred->luc_ginfo)
 547                         RETURN(0);
 548
 549                 /* Note: freeing a group_info count on 'nblocks' instead of
 550                  * 'ngroups', thus we can safely alloc enough buffer and reduce
 551                  * and ngroups number later.
 552                  */
 553                 gnew = groups_alloc(rsd->rsd_ngroups);
 554                 if (!gnew) {
 555                         CERROR("out of memory\n");
 556                         drop_ucred_ginfo(ucred);
 557                         mds_put_group_entry(NULL, ucred->luc_ghash);
 558                         RETURN(-ENOMEM);
 559                 }
 560
 561                 ginfo = ucred->luc_ginfo;
 562                 while (cur < rsd->rsd_ngroups) {
 563                         if (groups_search(ginfo, rsd->rsd_groups[cur]))
 564                                 GROUP_AT(gnew, set++) = rsd->rsd_groups[cur];
 565                         cur++;
 566                 }
 567                 gnew->ngroups = set;
 568
 569                 put_group_info(ucred->luc_ginfo);
 570                 ucred->luc_ginfo = gnew;
 571         }
 572         RETURN(0);
 573 }
 574
 575 void mds_exit_ucred(struct lvfs_ucred *ucred)
 576 {
 577         ENTRY;
 578
 579         if (ucred->luc_ginfo)
 580                 put_group_info(ucred->luc_ginfo);
 581         if (ucred->luc_ghash)
 582                 mds_put_group_entry(NULL, ucred->luc_ghash);
 583
 584         EXIT;
 585 }