lustre/lov/lov_merge.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2002, 2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of the Lustre file system, http://www.lustre.org
   7  *   Lustre is a trademark of Cluster File Systems, Inc.
   8  *
   9  *   You may have signed or agreed to another license before downloading
  10  *   this software.  If so, you are bound by the terms and conditions
  11  *   of that agreement, and the following does not apply to you.  See the
  12  *   LICENSE file included with this distribution for more information.
  13  *
  14  *   If you did not agree to a different license, then this copy of Lustre
  15  *   is open source software; you can redistribute it and/or modify it
  16  *   under the terms of version 2 of the GNU General Public License as
  17  *   published by the Free Software Foundation.
  18  *
  19  *   In either case, Lustre is distributed in the hope that it will be
  20  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  21  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *   license text for more details.
  23  */
  24
  25 #ifndef EXPORT_SYMTAB
  26 # define EXPORT_SYMTAB
  27 #endif
  28 #define DEBUG_SUBSYSTEM S_LOV
  29
  30 #ifdef __KERNEL__
  31 #include <libcfs/libcfs.h>
  32 #else
  33 #include <liblustre.h>
  34 #endif
  35
  36 #include <obd_class.h>
  37 #include <obd_lov.h>
  38
  39 #include "lov_internal.h"
  40
  41 /* Merge the lock value block(&lvb) attributes from each of the stripes in a
  42  * file into a single lvb. It is expected that the caller initializes the
  43  * current atime, mtime, ctime to avoid regressing a more uptodate time on
  44  * the local client.
  45  *
  46  * If @kms_only is set then we do not consider the recently seen size (rss)
  47  * when updating the known minimum size (kms).  Even when merging RSS, we will
  48  * take the KMS value if it's larger.  This prevents getattr from stomping on
  49  * dirty cached pages which extend the file size. */
  50 int lov_merge_lvb(struct obd_export *exp, struct lov_stripe_md *lsm,
  51                   struct ost_lvb *lvb, int kms_only)
  52 {
  53         __u64 size = 0;
  54         __u64 blocks = 0;
  55         __u64 current_mtime = lvb->lvb_mtime;
  56         __u64 current_atime = lvb->lvb_atime;
  57         __u64 current_ctime = lvb->lvb_ctime;
  58         int i;
  59         int rc = 0;
  60
  61         LASSERT_SPIN_LOCKED(&lsm->lsm_lock);
  62 #ifdef __KERNEL__
  63         LASSERT(lsm->lsm_lock_owner == cfs_current());
  64 #endif
  65
  66         for (i = 0; i < lsm->lsm_stripe_count; i++) {
  67                 struct lov_oinfo *loi = lsm->lsm_oinfo[i];
  68                 obd_size lov_size, tmpsize;
  69
  70                 if (OST_LVB_IS_ERR(loi->loi_lvb.lvb_blocks)) {
  71                         rc = OST_LVB_GET_ERR(loi->loi_lvb.lvb_blocks);
  72                         continue;
  73                 }
  74
  75                 tmpsize = loi->loi_kms;
  76                 if (kms_only == 0 && loi->loi_lvb.lvb_size > tmpsize)
  77                         tmpsize = loi->loi_lvb.lvb_size;
  78
  79                 lov_size = lov_stripe_size(lsm, tmpsize, i);
  80                 if (lov_size > size)
  81                         size = lov_size;
  82                 /* merge blocks, mtime, atime */
  83                 blocks += loi->loi_lvb.lvb_blocks;
  84                 if (loi->loi_lvb.lvb_atime > current_atime)
  85                         current_atime = loi->loi_lvb.lvb_atime;
  86
  87                 /* mtime is always updated with ctime, but can be set in past.
  88                    As write and utime(2) may happen within 1 second, and utime's
  89                    mtime has a priority over write's one, leave mtime from mds
  90                    for the same ctimes. */
  91                 if (loi->loi_lvb.lvb_ctime > current_ctime) {
  92                         current_ctime = loi->loi_lvb.lvb_ctime;
  93                         current_mtime = loi->loi_lvb.lvb_mtime;
  94                 }
  95         }
  96
  97         lvb->lvb_size = size;
  98         lvb->lvb_blocks = blocks;
  99         lvb->lvb_mtime = current_mtime;
 100         lvb->lvb_atime = current_atime;
 101         lvb->lvb_ctime = current_ctime;
 102         RETURN(rc);
 103 }
 104
 105 /* Must be called under the lov_stripe_lock() */
 106 int lov_adjust_kms(struct obd_export *exp, struct lov_stripe_md *lsm,
 107                    obd_off size, int shrink)
 108 {
 109         struct lov_oinfo *loi;
 110         int stripe = 0;
 111         __u64 kms;
 112         ENTRY;
 113
 114         LASSERT_SPIN_LOCKED(&lsm->lsm_lock);
 115 #ifdef __KERNEL__
 116         LASSERT(lsm->lsm_lock_owner == cfs_current());
 117 #endif
 118
 119         if (shrink) {
 120                 for (; stripe < lsm->lsm_stripe_count; stripe++) {
 121                         struct lov_oinfo *loi = lsm->lsm_oinfo[stripe];
 122                         kms = lov_size_to_stripe(lsm, size, stripe);
 123                         CDEBUG(D_INODE,
 124                                "stripe %d KMS %sing "LPU64"->"LPU64"\n",
 125                                stripe, kms > loi->loi_kms ? "increas":"shrink",
 126                                loi->loi_kms, kms);
 127                         loi->loi_kms = loi->loi_lvb.lvb_size = kms;
 128                 }
 129                 RETURN(0);
 130         }
 131
 132         if (size > 0)
 133                 stripe = lov_stripe_number(lsm, size - 1);
 134         kms = lov_size_to_stripe(lsm, size, stripe);
 135         loi = lsm->lsm_oinfo[stripe];
 136
 137         CDEBUG(D_INODE, "stripe %d KMS %sincreasing "LPU64"->"LPU64"\n",
 138                stripe, kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms);
 139         if (kms > loi->loi_kms)
 140                 loi->loi_kms = kms;
 141
 142         RETURN(0);
 143 }
 144
 145 void lov_merge_attrs(struct obdo *tgt, struct obdo *src, obd_flag valid,
 146                      struct lov_stripe_md *lsm, int stripeno, int *set)
 147 {
 148         valid &= src->o_valid;
 149
 150         if (*set) {
 151                 if (valid & OBD_MD_FLSIZE) {
 152                         /* this handles sparse files properly */
 153                         obd_size lov_size;
 154
 155                         lov_size = lov_stripe_size(lsm, src->o_size, stripeno);
 156                         if (lov_size > tgt->o_size)
 157                                 tgt->o_size = lov_size;
 158                 }
 159                 if (valid & OBD_MD_FLBLOCKS)
 160                         tgt->o_blocks += src->o_blocks;
 161                 if (valid & OBD_MD_FLBLKSZ)
 162                         tgt->o_blksize += src->o_blksize;
 163                 if (valid & OBD_MD_FLCTIME && tgt->o_ctime < src->o_ctime)
 164                         tgt->o_ctime = src->o_ctime;
 165                 /* Only mtime from OSTs are merged here, as they cannot be set
 166                    in past (only MDS's mtime can) do not look at ctime. */
 167                 if (valid & OBD_MD_FLMTIME && tgt->o_mtime < src->o_mtime)
 168                         tgt->o_mtime = src->o_mtime;
 169         } else {
 170                 memcpy(tgt, src, sizeof(*tgt));
 171                 tgt->o_id = lsm->lsm_object_id;
 172                 if (valid & OBD_MD_FLSIZE)
 173                         tgt->o_size = lov_stripe_size(lsm,src->o_size,stripeno);
 174                 *set = 1;
 175         }
 176 }