1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <sys/param.h>
29 #include <sys/types.h>
30 #include <sys/systm.h>
31 #include <sys/cred.h>
32 #include <sys/proc.h>
33 #include <sys/user.h>
34 #include <sys/vfs.h>
35 #include <sys/vnode.h>
36 #include <sys/pathname.h>
37 #include <sys/uio.h>
38 #include <sys/tiuser.h>
39 #include <sys/sysmacros.h>
40 #include <sys/kmem.h>
41 #include <netinet/in.h>
42 #include <sys/mount.h>
43 #include <sys/ioctl.h>
44 #include <sys/statvfs.h>
45 #include <sys/errno.h>
46 #include <sys/debug.h>
47 #include <sys/cmn_err.h>
48 #include <sys/utsname.h>
49 #include <sys/bootconf.h>
50 #include <sys/modctl.h>
51
52 #include <vm/hat.h>
53 #include <vm/as.h>
54 #include <vm/page.h>
55 #include <vm/pvn.h>
56 #include <vm/seg.h>
57 #include <vm/seg_map.h>
58 #include <vm/seg_vn.h>
59 #include <vm/rm.h>
60 #include <sys/fs/cachefs_fs.h>
61
62 #define C_CACHE_VALID(SAVED_MTIME, NEW_MTIME) \
63 ((SAVED_MTIME.tv_sec == NEW_MTIME.tv_sec) && \
64 (SAVED_MTIME.tv_nsec == NEW_MTIME.tv_nsec))
65
66 static time_t cachefs_gettime_cached_object(struct fscache *fscp,
67 struct cnode *cp, time_t mtime);
68
69 static int
70 c_strict_init_cached_object(fscache_t *fscp, cnode_t *cp, vattr_t *vap,
71 cred_t *cr)
72 {
73 int error;
74 cachefs_metadata_t *mdp = &cp->c_metadata;
75
76 ASSERT(cr);
77 ASSERT(MUTEX_HELD(&cp->c_statelock));
78
79 /* if attributes not passed in then get them */
80 if (vap == NULL) {
81 /* if not connected then cannot get attrs */
82 if ((fscp->fs_cdconnected != CFS_CD_CONNECTED) ||
83 (fscp->fs_backvfsp == NULL))
84 return (ETIMEDOUT);
85
86 /* get backvp if necessary */
87 if (cp->c_backvp == NULL) {
88 error = cachefs_getbackvp(fscp, cp);
89 if (error)
90 return (error);
91 }
92
93 /* get the attributes */
94 cp->c_attr.va_mask = AT_ALL;
95 error = VOP_GETATTR(cp->c_backvp, &cp->c_attr, 0, cr, NULL);
96 if (error)
97 return (error);
98 } else {
99 /* copy passed in attributes into the cnode */
100 cp->c_attr = *vap;
101 }
102
103 /*
104 * Expire time is based on the number of seconds since
105 * the last change.
106 * (i.e. files that changed recently are likely to change soon)
107 */
108 mdp->md_x_time.tv_nsec = 0;
109 mdp->md_x_time.tv_sec = cachefs_gettime_cached_object(fscp, cp,
110 cp->c_attr.va_mtime.tv_sec);
111 mdp->md_consttype = CFS_FS_CONST_STRICT;
112 cp->c_size = cp->c_attr.va_size;
113 cp->c_flags |= CN_UPDATED;
114
115 return (0);
116 }
117
118 static int
119 c_strict_check_cached_object(struct fscache *fscp, struct cnode *cp,
120 int verify_what, cred_t *cr)
121 {
122 struct vattr attrs;
123 int error = 0;
124 int fail = 0, backhit = 0;
125 cachefs_metadata_t *mdp = &cp->c_metadata;
126
127 #ifdef CFSDEBUG
128 CFS_DEBUG(CFSDEBUG_VOPS)
129 printf("c_strict_check_cached_object: ENTER cp %p\n",
130 (void *)cp);
131 #endif
132
133 ASSERT(cr);
134 ASSERT(MUTEX_HELD(&cp->c_statelock));
135
136 if ((fscp->fs_cdconnected != CFS_CD_CONNECTED) ||
137 (fscp->fs_backvfsp == NULL))
138 goto out;
139
140 /*
141 * If backfs is NFSv4, do a getattr to update link count,
142 * all other attributes are not used, and the backfs is
143 * called on a getattr request.
144 */
145 if (CFS_ISFS_BACKFS_NFSV4(fscp)) {
146 backhit = 1;
147 attrs.va_mask = AT_ALL;
148 error = VOP_GETATTR(cp->c_backvp, &attrs, 0, cr, NULL);
149 if (error)
150 goto out;
151 cp->c_attr = attrs;
152 goto out;
153 }
154
155 /* done if do not have to check and time has not expired */
156 if (((verify_what & C_BACK_CHECK) == 0) &&
157 (gethrestime_sec() < mdp->md_x_time.tv_sec) &&
158 ((mdp->md_flags & MD_NEEDATTRS) == 0))
159 goto out;
160
161 /* get backvp if necessary */
162 if (cp->c_backvp == NULL) {
163 error = cachefs_getbackvp(fscp, cp);
164 if (error)
165 goto out;
166 }
167
168 /*
169 * If the cnode is being populated, and we're not the populating
170 * thread, then block until the pop thread completes. If we are the
171 * pop thread, then we may come in here, but not to nuke the directory
172 * cnode at a critical juncture.
173 */
174 again:
175 while ((cp->c_flags & CN_ASYNC_POP_WORKING) &&
176 (cp->c_popthrp != curthread)) {
177 cv_wait(&cp->c_popcv, &cp->c_statelock);
178
179 /*
180 * recheck backvp and connectivity - if backvp now null,
181 * something bad happened, so don't bother trying to 'get' it
182 */
183 if ((cp->c_backvp == NULL) ||
184 (fscp->fs_cdconnected != CFS_CD_CONNECTED) ||
185 (fscp->fs_backvfsp == NULL)) {
186 if (cp->c_flags | CN_STALE) {
187 cp->c_flags |= CN_NOCACHE;
188 error = ESTALE;
189 }
190 goto out;
191 }
192 }
193
194 /* get the file attributes from the back fs */
195 attrs.va_mask = AT_ALL;
196 error = VOP_GETATTR(cp->c_backvp, &attrs, 0, cr, NULL);
197 backhit = 1;
198 if (error)
199 goto out;
200
201 /* if the mtime or size of the file has changed */
202 if ((!C_CACHE_VALID(mdp->md_vattr.va_mtime, attrs.va_mtime) ||
203 (cp->c_size != attrs.va_size)) &&
204 ((mdp->md_flags & MD_NEEDATTRS) == 0)) {
205 fail = 1;
206 #ifdef CFSDEBUG
207 CFS_DEBUG(CFSDEBUG_INVALIDATE)
208 printf("c_strict_check: invalidating %llu\n",
209 (u_longlong_t)cp->c_id.cid_fileno);
210 #endif
211 if (vn_has_cached_data(CTOV(cp))) {
212 mutex_exit(&cp->c_statelock);
213 error = cachefs_putpage_common(CTOV(cp),
214 (offset_t)0, 0, B_INVAL, cr);
215 mutex_enter(&cp->c_statelock);
216 if (CFS_TIMEOUT(fscp, error))
217 goto out;
218 error = 0;
219 /*
220 * if an async pop started while the lock was
221 * dropped, go back and try again
222 */
223 if ((cp->c_flags & CN_ASYNC_POP_WORKING) &&
224 (cp->c_popthrp != curthread))
225 goto again;
226 }
227 /*
228 * We should properly handle the CN_NOCACHE flag here.
229 * In fact, we should remember that cachefs_inval_object()
230 * forcibly sets/unsets the flag, so we should keep a
231 * state of the flag over the call.
232 */
233 if ((cp->c_flags & CN_NOCACHE) == 0)
234 cachefs_inval_object(cp);
235 else {
236 cachefs_inval_object(cp);
237 cp->c_flags |= CN_NOCACHE;
238 }
239 if ((CTOV(cp))->v_type == VREG) {
240 attrs.va_mask = AT_ALL;
241 error = VOP_GETATTR(cp->c_backvp, &attrs, 0, cr, NULL);
242 if (error)
243 goto out;
244 }
245 if (!vn_has_cached_data(CTOV(cp))) {
246 cp->c_size = attrs.va_size;
247 }
248 #ifdef CFSDEBUG
249 else {
250 CFS_DEBUG(CFSDEBUG_VOPS)
251 printf("c_strict_check: v_pages not null\n");
252 }
253 #endif
254 }
255
256 /* toss cached acl info if ctime changed */
257 if (!C_CACHE_VALID(mdp->md_vattr.va_ctime, attrs.va_ctime)) {
258 cachefs_purgeacl(cp);
259 }
260
261 cp->c_attr = attrs;
262 if (attrs.va_size > cp->c_size)
263 cp->c_size = attrs.va_size;
264 mdp->md_x_time.tv_sec =
265 cachefs_gettime_cached_object(fscp, cp, attrs.va_mtime.tv_sec);
266 mdp->md_flags &= ~MD_NEEDATTRS;
267 cachefs_cnode_setlocalstats(cp);
268 cp->c_flags |= CN_UPDATED;
269
270 out:
271 if (backhit != 0) {
272 if (fail != 0)
273 fscp->fs_stats.st_fails++;
274 else
275 fscp->fs_stats.st_passes++;
276 }
277
278 #ifdef CFSDEBUG
279 CFS_DEBUG(CFSDEBUG_VOPS)
280 printf("c_strict_check_cached_object: EXIT expires %lx\n",
281 (long)mdp->md_x_time.tv_sec);
282 #endif
283 return (error);
284 }
285
286 static void
287 c_strict_modify_cached_object(struct fscache *fscp, struct cnode *cp,
288 cred_t *cr)
289 {
290 struct vattr attrs;
291 int error = 0;
292 nlink_t nlink;
293 cachefs_metadata_t *mdp = &cp->c_metadata;
294
295 ASSERT(MUTEX_HELD(&cp->c_statelock));
296 ASSERT(fscp->fs_cdconnected == CFS_CD_CONNECTED);
297 ASSERT(fscp->fs_backvfsp);
298
299 /*
300 * Don't do a getattr if NFSv4, which maintains
301 * its attributes (and link count) by doing a call
302 * to CFSOP_CHECK_COBJECT() during vnode operations.
303 */
304 if (CFS_ISFS_BACKFS_NFSV4(fscp))
305 goto out;
306
307 fscp->fs_stats.st_modifies++;
308
309 /* from now on, make sure we're using the server's idea of time */
310 mdp->md_flags &= ~(MD_LOCALCTIME | MD_LOCALMTIME);
311 mdp->md_flags |= MD_NEEDATTRS;
312
313 /* if in write-around mode, make sure file is nocached */
314 if (CFS_ISFS_WRITE_AROUND(fscp)) {
315 if ((cp->c_flags & CN_NOCACHE) == 0)
316 cachefs_nocache(cp);
317
318 /*
319 * If a directory, then defer getting the new attributes
320 * until requested. Might be a little bit faster this way.
321 */
322 if (CTOV(cp)->v_type == VDIR)
323 goto out;
324 }
325
326 /* get the new mtime so the next call to check_cobject does not fail */
327 if (cp->c_backvp == NULL) {
328 error = cachefs_getbackvp(fscp, cp);
329 if (error) {
330 mdp->md_vattr.va_mtime.tv_sec = 0;
331 goto out;
332 }
333 }
334
335 attrs.va_mask = AT_ALL;
336 ASSERT(cp->c_backvp != NULL);
337 error = VOP_GETATTR(cp->c_backvp, &attrs, 0, cr, NULL);
338 if (error) {
339 mdp->md_vattr.va_mtime.tv_sec = 0;
340 goto out;
341 }
342
343 mdp->md_x_time.tv_sec =
344 cachefs_gettime_cached_object(fscp, cp, attrs.va_mtime.tv_sec);
345 nlink = cp->c_attr.va_nlink;
346 cp->c_attr = attrs;
347 cp->c_attr.va_nlink = nlink;
348 if ((attrs.va_size > cp->c_size) || !vn_has_cached_data(CTOV(cp)))
349 cp->c_size = attrs.va_size;
350 mdp->md_flags &= ~MD_NEEDATTRS;
351 cachefs_cnode_setlocalstats(cp);
352 out:
353 cp->c_flags |= CN_UPDATED;
354 }
355
356 /*ARGSUSED*/
357 static void
358 c_strict_invalidate_cached_object(struct fscache *fscp, struct cnode *cp,
359 cred_t *cr)
360 {
361 cachefs_metadata_t *mdp = &cp->c_metadata;
362
363 ASSERT(MUTEX_HELD(&cp->c_statelock));
364 mdp->md_vattr.va_mtime.tv_sec = 0;
365 mdp->md_flags |= MD_NEEDATTRS;
366 cp->c_flags |= CN_UPDATED;
367 }
368
369 /*ARGSUSED*/
370 static void
371 c_strict_convert_cached_object(struct fscache *fscp, struct cnode *cp,
372 cred_t *cr)
373 {
374 cachefs_metadata_t *mdp = &cp->c_metadata;
375
376 ASSERT(MUTEX_HELD(&cp->c_statelock));
377 mdp->md_flags |= MD_NEEDATTRS;
378 mdp->md_consttype = CFS_FS_CONST_STRICT;
379 cp->c_flags |= CN_UPDATED;
380 }
381
382 /*
383 * Returns the tod in secs when the consistency of the object should
384 * be checked.
385 */
386 static time_t
387 cachefs_gettime_cached_object(struct fscache *fscp, struct cnode *cp,
388 time_t mtime)
389 {
390 time_t xsec;
391 time_t acmin, acmax;
392 time_t now;
393
394 /*
395 * Expire time is based on the number of seconds since the last change
396 * (i.e. files that changed recently are likely to change soon),
397 */
398 if ((CTOV(cp))->v_type == VDIR) {
399 acmin = fscp->fs_acdirmin;
400 acmax = fscp->fs_acdirmax;
401 } else {
402 acmin = fscp->fs_acregmin;
403 acmax = fscp->fs_acregmax;
404 }
405
406 now = gethrestime_sec();
407 xsec = now - mtime;
408 xsec = MAX(xsec, acmin);
409 xsec = MIN(xsec, acmax);
410 xsec += now;
411 return (xsec);
412 }
413
414 struct cachefsops strictcfsops = {
415 c_strict_init_cached_object,
416 c_strict_check_cached_object,
417 c_strict_modify_cached_object,
418 c_strict_invalidate_cached_object,
419 c_strict_convert_cached_object
420 };