Whamcloud - gitweb
LU-911 obdclass: la_from_obdo helper
[fs/lustre-release.git] / lustre / obdclass / linux / linux-obdo.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/obdclass/linux/linux-obdo.c
37  *
38  * Object Devices Class Driver
39  * These are the only exported functions, they provide some generic
40  * infrastructure for managing object devices
41  */
42
43 #define DEBUG_SUBSYSTEM S_CLASS
44 #ifndef EXPORT_SYMTAB
45 # define EXPORT_SYMTAB
46 #endif
47
48 #ifndef __KERNEL__
49 #include <liblustre.h>
50 #else
51 #include <linux/module.h>
52 #include <obd_class.h>
53 #include <lustre/lustre_idl.h>
54 #endif
55
56 #ifdef __KERNEL__
57 #include <linux/fs.h>
58 #include <linux/pagemap.h> /* for PAGE_CACHE_SIZE */
59
60 /*FIXME: Just copy from obdo_from_inode*/
61 void obdo_from_la(struct obdo *dst, struct lu_attr *la, __u64 valid)
62 {
63         obd_flag newvalid = 0;
64
65         if (valid & LA_ATIME) {
66                 dst->o_atime = la->la_atime;
67                 newvalid |= OBD_MD_FLATIME;
68         }
69         if (valid & LA_MTIME) {
70                 dst->o_mtime = la->la_mtime;
71                 newvalid |= OBD_MD_FLMTIME;
72         }
73         if (valid & LA_CTIME) {
74                 dst->o_ctime = la->la_ctime;
75                 newvalid |= OBD_MD_FLCTIME;
76         }
77         if (valid & LA_SIZE) {
78                 dst->o_size = la->la_size;
79                 newvalid |= OBD_MD_FLSIZE;
80         }
81         if (valid & LA_BLOCKS) {  /* allocation of space (x512 bytes) */
82                 dst->o_blocks = la->la_blocks;
83                 newvalid |= OBD_MD_FLBLOCKS;
84         }
85         if (valid & LA_TYPE) {
86                 dst->o_mode = (dst->o_mode & S_IALLUGO) |
87                               (la->la_mode & S_IFMT);
88                 newvalid |= OBD_MD_FLTYPE;
89         }
90         if (valid & LA_MODE) {
91                 dst->o_mode = (dst->o_mode & S_IFMT) |
92                               (la->la_mode & S_IALLUGO);
93                 newvalid |= OBD_MD_FLMODE;
94         }
95         if (valid & LA_UID) {
96                 dst->o_uid = la->la_uid;
97                 newvalid |= OBD_MD_FLUID;
98         }
99         if (valid & LA_GID) {
100                 dst->o_gid = la->la_gid;
101                 newvalid |= OBD_MD_FLGID;
102         }
103         dst->o_valid |= newvalid;
104 }
105 EXPORT_SYMBOL(obdo_from_la);
106
107 /*FIXME: Just copy from obdo_from_inode*/
108 void la_from_obdo(struct lu_attr *dst, struct obdo *obdo, obd_flag valid)
109 {
110         __u64 newvalid = 0;
111
112         valid &= obdo->o_valid;
113
114         if (valid & OBD_MD_FLATIME) {
115                 dst->la_atime = obdo->o_atime;
116                 newvalid |= LA_ATIME;
117         }
118         if (valid & OBD_MD_FLMTIME) {
119                 dst->la_mtime = obdo->o_mtime;
120                 newvalid |= LA_MTIME;
121         }
122         if (valid & OBD_MD_FLCTIME) {
123                 dst->la_ctime = obdo->o_ctime;
124                 newvalid |= LA_CTIME;
125         }
126         if (valid & OBD_MD_FLSIZE) {
127                 dst->la_size = obdo->o_size;
128                 newvalid |= LA_SIZE;
129         }
130         if (valid & OBD_MD_FLBLOCKS) {
131                 dst->la_blocks = obdo->o_blocks;
132                 newvalid |= LA_BLOCKS;
133         }
134         if (valid & OBD_MD_FLTYPE) {
135                 dst->la_mode = (dst->la_mode & S_IALLUGO) |
136                                (obdo->o_mode & S_IFMT);
137                 newvalid |= LA_TYPE;
138         }
139         if (valid & OBD_MD_FLMODE) {
140                 dst->la_mode = (dst->la_mode & S_IFMT) |
141                                (obdo->o_mode & S_IALLUGO);
142                 newvalid |= LA_MODE;
143         }
144         if (valid & OBD_MD_FLUID) {
145                 dst->la_uid = obdo->o_uid;
146                 newvalid |= LA_UID;
147         }
148         if (valid & OBD_MD_FLGID) {
149                 dst->la_gid = obdo->o_gid;
150                 newvalid |= LA_GID;
151         }
152         dst->la_valid = newvalid;
153 }
154 EXPORT_SYMBOL(la_from_obdo);
155
156 void obdo_refresh_inode(struct inode *dst, struct obdo *src, obd_flag valid)
157 {
158         valid &= src->o_valid;
159
160         if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
161                 CDEBUG(D_INODE,
162                        "valid "LPX64", cur time %lu/%lu, new "LPU64"/"LPU64"\n",
163                        src->o_valid, LTIME_S(dst->i_mtime),
164                        LTIME_S(dst->i_ctime), src->o_mtime, src->o_ctime);
165
166         if (valid & OBD_MD_FLATIME && src->o_atime > LTIME_S(dst->i_atime))
167                 LTIME_S(dst->i_atime) = src->o_atime;
168         if (valid & OBD_MD_FLMTIME && src->o_mtime > LTIME_S(dst->i_mtime))
169                 LTIME_S(dst->i_mtime) = src->o_mtime;
170         if (valid & OBD_MD_FLCTIME && src->o_ctime > LTIME_S(dst->i_ctime))
171                 LTIME_S(dst->i_ctime) = src->o_ctime;
172         if (valid & OBD_MD_FLSIZE)
173                 i_size_write(dst, src->o_size);
174         /* optimum IO size */
175         if (valid & OBD_MD_FLBLKSZ && src->o_blksize > (1 << dst->i_blkbits)) {
176                 dst->i_blkbits = cfs_ffs(src->o_blksize) - 1;
177 #ifdef HAVE_INODE_BLKSIZE
178                 dst->i_blksize = src->o_blksize;
179 #endif
180         }
181
182         if (dst->i_blkbits < CFS_PAGE_SHIFT) {
183 #ifdef HAVE_INODE_BLKSIZE
184                 dst->i_blksize = CFS_PAGE_SIZE;
185 #endif
186                 dst->i_blkbits = CFS_PAGE_SHIFT;
187         }
188
189         /* allocation of space */
190         if (valid & OBD_MD_FLBLOCKS && src->o_blocks > dst->i_blocks)
191                 /*
192                  * XXX shouldn't overflow be checked here like in
193                  * obdo_to_inode().
194                  */
195                 dst->i_blocks = src->o_blocks;
196 }
197 EXPORT_SYMBOL(obdo_refresh_inode);
198
199 void obdo_to_inode(struct inode *dst, struct obdo *src, obd_flag valid)
200 {
201         valid &= src->o_valid;
202
203         LASSERTF(!(valid & (OBD_MD_FLTYPE | OBD_MD_FLGENER | OBD_MD_FLFID |
204                             OBD_MD_FLID | OBD_MD_FLGROUP)),
205                  "object "LPU64"/"LPU64", valid %x\n",
206                  src->o_id, src->o_seq, valid);
207
208         if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
209                 CDEBUG(D_INODE,
210                        "valid "LPX64", cur time %lu/%lu, new "LPU64"/"LPU64"\n",
211                        src->o_valid, LTIME_S(dst->i_mtime),
212                        LTIME_S(dst->i_ctime), src->o_mtime, src->o_ctime);
213
214         if (valid & OBD_MD_FLATIME)
215                 LTIME_S(dst->i_atime) = src->o_atime;
216         if (valid & OBD_MD_FLMTIME)
217                 LTIME_S(dst->i_mtime) = src->o_mtime;
218         if (valid & OBD_MD_FLCTIME && src->o_ctime > LTIME_S(dst->i_ctime))
219                 LTIME_S(dst->i_ctime) = src->o_ctime;
220         if (valid & OBD_MD_FLSIZE)
221                 i_size_write(dst, src->o_size);
222         if (valid & OBD_MD_FLBLOCKS) { /* allocation of space */
223                 dst->i_blocks = src->o_blocks;
224                 if (dst->i_blocks < src->o_blocks) /* overflow */
225                         dst->i_blocks = -1;
226
227         }
228         if (valid & OBD_MD_FLBLKSZ) {
229                 dst->i_blkbits = cfs_ffs(src->o_blksize)-1;
230 #ifdef HAVE_INODE_BLKSIZE
231                 dst->i_blksize = src->o_blksize;
232 #endif
233         }
234         if (valid & OBD_MD_FLMODE)
235                 dst->i_mode = (dst->i_mode & S_IFMT) | (src->o_mode & ~S_IFMT);
236         if (valid & OBD_MD_FLUID)
237                 dst->i_uid = src->o_uid;
238         if (valid & OBD_MD_FLGID)
239                 dst->i_gid = src->o_gid;
240         if (valid & OBD_MD_FLFLAGS)
241                 dst->i_flags = src->o_flags;
242 }
243 EXPORT_SYMBOL(obdo_to_inode);
244 #endif