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         struct lov_oinfo *loi;
  54         __u64 size = 0;
  55         __u64 blocks = 0;
  56         __u64 current_mtime = lvb->lvb_mtime;
  57         __u64 current_atime = lvb->lvb_atime;
  58         __u64 current_ctime = lvb->lvb_ctime;
  59         int i;
  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, loi = lsm->lsm_oinfo; i < lsm->lsm_stripe_count;
  67              i++, loi++) {
  68                 obd_size lov_size, tmpsize;
  69
  70                 tmpsize = loi->loi_kms;
  71                 if (kms_only == 0 && loi->loi_lvb.lvb_size > tmpsize)
  72                         tmpsize = loi->loi_lvb.lvb_size;
  73
  74                 lov_size = lov_stripe_size(lsm, tmpsize, i);
  75                 if (lov_size > size)
  76                         size = lov_size;
  77                 /* merge blocks, mtime, atime */
  78                 blocks += loi->loi_lvb.lvb_blocks;
  79                 if (loi->loi_lvb.lvb_atime > current_atime)
  80                         current_atime = loi->loi_lvb.lvb_atime;
  81
  82                 /* mtime is always updated with ctime, but can be set in past.
  83                    As write and utime(2) may happen within 1 second, and utime's
  84                    mtime has a priority over write's one, leave mtime from mds
  85                    for the same ctimes. */
  86                 if (loi->loi_lvb.lvb_ctime > current_ctime) {
  87                         current_ctime = loi->loi_lvb.lvb_ctime;
  88                         current_mtime = loi->loi_lvb.lvb_mtime;
  89                 }
  90         }
  91
  92         lvb->lvb_size = size;
  93         lvb->lvb_blocks = blocks;
  94         lvb->lvb_mtime = current_mtime;
  95         lvb->lvb_atime = current_atime;
  96         lvb->lvb_ctime = current_ctime;
  97         RETURN(0);
  98 }
  99
 100 /* Must be called under the lov_stripe_lock() */
 101 int lov_adjust_kms(struct obd_export *exp, struct lov_stripe_md *lsm,
 102                    obd_off size, int shrink)
 103 {
 104         struct lov_oinfo *loi;
 105         int stripe = 0;
 106         __u64 kms;
 107         ENTRY;
 108
 109         LASSERT_SPIN_LOCKED(&lsm->lsm_lock);
 110 #ifdef __KERNEL__
 111         LASSERT(lsm->lsm_lock_owner == cfs_current());
 112 #endif
 113
 114         if (shrink) {
 115                 struct lov_oinfo *loi;
 116                 for (loi = lsm->lsm_oinfo; stripe < lsm->lsm_stripe_count;
 117                      stripe++, loi++) {
 118                         kms = lov_size_to_stripe(lsm, size, stripe);
 119                         CDEBUG(D_INODE,
 120                                "stripe %d KMS %sing "LPU64"->"LPU64"\n",
 121                                stripe, kms > loi->loi_kms ? "increas" :
 122                                kms < loi->loi_kms ? "shrink" : "leav",
 123                                loi->loi_kms, kms);
 124                         loi->loi_kms = loi->loi_lvb.lvb_size = kms;
 125                 }
 126                 RETURN(0);
 127         }
 128
 129         if (size > 0)
 130                 stripe = lov_stripe_number(lsm, size - 1);
 131         kms = lov_size_to_stripe(lsm, size, stripe);
 132         loi = &(lsm->lsm_oinfo[stripe]);
 133
 134         CDEBUG(D_INODE, "stripe %d KMS %sincreasing "LPU64"->"LPU64"\n",
 135                stripe, kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms);
 136         if (kms > loi->loi_kms)
 137                 loi->loi_kms = kms;
 138
 139         RETURN(0);
 140 }
 141
 142 void lov_merge_attrs(struct obdo *tgt, struct obdo *src, obd_flag valid,
 143                      struct lov_stripe_md *lsm, int stripeno, int *set)
 144 {
 145         valid &= src->o_valid;
 146
 147         if (*set) {
 148                 if (valid & OBD_MD_FLSIZE) {
 149                         /* this handles sparse files properly */
 150                         obd_size lov_size;
 151
 152                         lov_size = lov_stripe_size(lsm, src->o_size, stripeno);
 153                         if (lov_size > tgt->o_size)
 154                                 tgt->o_size = lov_size;
 155                 }
 156                 if (valid & OBD_MD_FLBLOCKS)
 157                         tgt->o_blocks += src->o_blocks;
 158                 if (valid & OBD_MD_FLBLKSZ)
 159                         tgt->o_blksize += src->o_blksize;
 160                 if (valid & OBD_MD_FLCTIME && tgt->o_ctime < src->o_ctime)
 161                         tgt->o_ctime = src->o_ctime;
 162                 /* Only mtime from OSTs are merged here, as they cannot be set
 163                    in past (only MDS's mtime can) do not look at ctime. */
 164                 if (valid & OBD_MD_FLMTIME && tgt->o_mtime < src->o_mtime)
 165                         tgt->o_mtime = src->o_mtime;
 166         } else {
 167                 memcpy(tgt, src, sizeof(*tgt));
 168                 tgt->o_id = lsm->lsm_object_id;
 169                 if (valid & OBD_MD_FLSIZE)
 170                         tgt->o_size = lov_stripe_size(lsm,src->o_size,stripeno);
 171                 *set = 1;
 172         }
 173 }