xref: /titanic_41/usr/src/uts/common/fs/cachefs/cachefs_strict.c (revision e4d060fb4c00d44cd578713eb9a921f594b733b8)
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 };
421