1 /* $NetBSD: chfs_subr.c,v 1.9 2013/10/20 17:18:38 christos Exp $ */
2
3 /*-
4 * Copyright (c) 2010 Department of Software Engineering,
5 * University of Szeged, Hungary
6 * Copyright (C) 2010 Tamas Toth <ttoth@inf.u-szeged.hu>
7 * Copyright (C) 2010 Adam Hoka <ahoka@NetBSD.org>
8 * All rights reserved.
9 *
10 * This code is derived from software contributed to The NetBSD Foundation
11 * by the Department of Software Engineering, University of Szeged, Hungary
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36
37 #include <sys/param.h>
38 #include <sys/dirent.h>
39 #include <sys/event.h>
40 #include <sys/kmem.h>
41 #include <sys/mount.h>
42 #include <sys/namei.h>
43 #include <sys/time.h>
44 #include <sys/stat.h>
45 #include <sys/systm.h>
46 #include <sys/swap.h>
47 #include <sys/vnode.h>
48 #include <sys/kauth.h>
49 #include <sys/proc.h>
50 #include <sys/atomic.h>
51
52 #include <uvm/uvm.h>
53
54 #include <miscfs/specfs/specdev.h>
55 #include <miscfs/genfs/genfs.h>
56 #include "chfs.h"
57
58
59 /*
60 * chfs_mem_info -
61 * Returns information about the number of available memory pages,
62 * including physical and virtual ones.
63 *
64 * If 'total' is true, the value returned is the total amount of memory
65 * pages configured for the system (either in use or free).
66 * If it is FALSE, the value returned is the amount of free memory pages.
67 *
68 * Remember to remove DUMMYFS_PAGES_RESERVED from the returned value to avoid
69 * excessive memory usage.
70 *
71 */
72 size_t
chfs_mem_info(bool total)73 chfs_mem_info(bool total)
74 {
75 size_t size;
76
77 size = 0;
78 size += uvmexp.swpgavail;
79 if (!total) {
80 size -= uvmexp.swpgonly;
81 }
82 size += uvmexp.free;
83 size += uvmexp.filepages;
84 if (size > uvmexp.wired) {
85 size -= uvmexp.wired;
86 } else {
87 size = 0;
88 }
89
90 return size;
91 }
92
93
94 /*
95 * chfs_dir_lookup -
96 * Looks for a directory entry in the directory represented by node.
97 * 'cnp' describes the name of the entry to look for. Note that the .
98 * and .. components are not allowed as they do not physically exist
99 * within directories.
100 *
101 * Returns a pointer to the entry when found, otherwise NULL.
102 */
103 struct chfs_dirent *
chfs_dir_lookup(struct chfs_inode * ip,struct componentname * cnp)104 chfs_dir_lookup(struct chfs_inode *ip, struct componentname *cnp)
105 {
106 bool found;
107 struct chfs_dirent *fd;
108 dbg("dir_lookup()\n");
109
110 KASSERT(IMPLIES(cnp->cn_namelen == 1, cnp->cn_nameptr[0] != '.'));
111 KASSERT(IMPLIES(cnp->cn_namelen == 2, !(cnp->cn_nameptr[0] == '.' &&
112 cnp->cn_nameptr[1] == '.')));
113
114 found = false;
115 TAILQ_FOREACH(fd, &ip->dents, fds) {
116 KASSERT(cnp->cn_namelen < 0xffff);
117 if (fd->vno == 0)
118 continue;
119 if (fd->nsize == (uint16_t)cnp->cn_namelen &&
120 memcmp(fd->name, cnp->cn_nameptr, fd->nsize) == 0) {
121 found = true;
122 break;
123 }
124 }
125
126 return found ? fd : NULL;
127 }
128
129 /*
130 * chfs_filldir -
131 * Creates a (kernel) dirent and moves it to the given memory address.
132 * Used during readdir.
133 */
134 int
chfs_filldir(struct uio * uio,ino_t ino,const char * name,int namelen,enum chtype type)135 chfs_filldir(struct uio* uio, ino_t ino, const char *name,
136 int namelen, enum chtype type)
137 {
138 struct dirent dent;
139 int error;
140
141 memset(&dent, 0, sizeof(dent));
142
143 dent.d_fileno = ino;
144 switch (type) {
145 case CHT_BLK:
146 dent.d_type = DT_BLK;
147 break;
148
149 case CHT_CHR:
150 dent.d_type = DT_CHR;
151 break;
152
153 case CHT_DIR:
154 dent.d_type = DT_DIR;
155 break;
156
157 case CHT_FIFO:
158 dent.d_type = DT_FIFO;
159 break;
160
161 case CHT_LNK:
162 dent.d_type = DT_LNK;
163 break;
164
165 case CHT_REG:
166 dent.d_type = DT_REG;
167 break;
168
169 case CHT_SOCK:
170 dent.d_type = DT_SOCK;
171 break;
172
173 default:
174 KASSERT(0);
175 }
176 dent.d_namlen = namelen;
177 (void)memcpy(dent.d_name, name, dent.d_namlen);
178 dent.d_reclen = _DIRENT_SIZE(&dent);
179
180 if (dent.d_reclen > uio->uio_resid) {
181 error = -1;
182 } else {
183 error = uiomove(&dent, dent.d_reclen, uio);
184 }
185
186 return error;
187 }
188
189 /*
190 * chfs_chsize - change size of the given vnode
191 * Caller should execute chfs_update on vp after a successful execution.
192 * The vnode must be locked on entry and remain locked on exit.
193 */
194 int
chfs_chsize(struct vnode * vp,u_quad_t size,kauth_cred_t cred)195 chfs_chsize(struct vnode *vp, u_quad_t size, kauth_cred_t cred)
196 {
197 struct chfs_mount *chmp;
198 struct chfs_inode *ip;
199
200 ip = VTOI(vp);
201 chmp = ip->chmp;
202
203 dbg("chfs_chsize\n");
204
205 switch (ip->ch_type) {
206 case CHT_DIR:
207 return EISDIR;
208 case CHT_LNK:
209 case CHT_REG:
210 if (vp->v_mount->mnt_flag & MNT_RDONLY)
211 return EROFS;
212 break;
213 case CHT_BLK:
214 case CHT_CHR:
215 case CHT_FIFO:
216 return 0;
217 default:
218 return EOPNOTSUPP; /* XXX why not ENODEV? */
219 }
220
221 vflushbuf(vp, 0);
222
223 mutex_enter(&chmp->chm_lock_mountfields);
224
225 if (ip->size < size) {
226 uvm_vnp_setsize(vp, size);
227 chfs_set_vnode_size(vp, size);
228 ip->iflag |= IN_CHANGE | IN_UPDATE;
229
230 mutex_exit(&chmp->chm_lock_mountfields);
231 return 0;
232 }
233
234 if (size != 0) {
235 ubc_zerorange(&vp->v_uobj, size, ip->size - size, UBC_UNMAP_FLAG(vp));
236 }
237
238 /* drop unused fragments */
239 chfs_truncate_fragtree(ip->chmp, &ip->fragtree, size);
240
241 uvm_vnp_setsize(vp, size);
242 chfs_set_vnode_size(vp, size);
243 ip->iflag |= IN_CHANGE | IN_UPDATE;
244 mutex_exit(&chmp->chm_lock_mountfields);
245 return 0;
246 }
247
248 /*
249 * chfs_chflags - change flags of the given vnode
250 * Caller should execute chfs_update on vp after a successful execution.
251 * The vnode must be locked on entry and remain locked on exit.
252 */
253 int
chfs_chflags(struct vnode * vp,int flags,kauth_cred_t cred)254 chfs_chflags(struct vnode *vp, int flags, kauth_cred_t cred)
255 {
256 struct chfs_inode *ip;
257 int error = 0;
258 kauth_action_t action = KAUTH_VNODE_WRITE_FLAGS;
259 bool changing_sysflags = false;
260
261 ip = VTOI(vp);
262
263 if (vp->v_mount->mnt_flag & MNT_RDONLY)
264 return EROFS;
265
266 if ((flags & SF_SNAPSHOT) != (ip->flags & SF_SNAPSHOT))
267 return EPERM;
268
269 /* Indicate we're changing system flags if we are. */
270 if ((ip->flags & SF_SETTABLE) != (flags & SF_SETTABLE) ||
271 (flags & UF_SETTABLE) != flags) {
272 action |= KAUTH_VNODE_WRITE_SYSFLAGS;
273 changing_sysflags = true;
274 }
275
276 /* Indicate the node has system flags if it does. */
277 if (ip->flags & (SF_IMMUTABLE | SF_APPEND)) {
278 action |= KAUTH_VNODE_HAS_SYSFLAGS;
279 }
280
281 error = kauth_authorize_vnode(cred, action, vp, NULL,
282 genfs_can_chflags(cred, CHTTOVT(ip->ch_type), ip->uid, changing_sysflags));
283 if (error)
284 return error;
285
286 if (changing_sysflags) {
287 ip->flags = flags;
288 } else {
289 ip->flags &= SF_SETTABLE;
290 ip->flags |= (flags & UF_SETTABLE);
291 }
292 ip->iflag |= IN_CHANGE;
293 error = chfs_update(vp, NULL, NULL, UPDATE_WAIT);
294 if (error)
295 return error;
296
297 if (flags & (IMMUTABLE | APPEND))
298 return 0;
299
300 return error;
301 }
302
303
304 /* chfs_itimes - updates a vnode times to the given data */
305 void
chfs_itimes(struct chfs_inode * ip,const struct timespec * acc,const struct timespec * mod,const struct timespec * cre)306 chfs_itimes(struct chfs_inode *ip, const struct timespec *acc,
307 const struct timespec *mod, const struct timespec *cre)
308 {
309 struct timespec now;
310
311 if (!(ip->iflag & (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY))) {
312 return;
313 }
314
315 vfs_timestamp(&now);
316 if (ip->iflag & IN_ACCESS) {
317 if (acc == NULL)
318 acc = &now;
319 ip->atime = acc->tv_sec;
320 }
321 if (ip->iflag & (IN_UPDATE | IN_MODIFY)) {
322 if (mod == NULL)
323 mod = &now;
324 ip->mtime = mod->tv_sec;
325 }
326 if (ip->iflag & (IN_CHANGE | IN_MODIFY)) {
327 if (cre == NULL)
328 cre = &now;
329 ip->ctime = cre->tv_sec;
330 }
331 if (ip->iflag & (IN_ACCESS | IN_MODIFY))
332 ip->iflag |= IN_ACCESSED;
333 if (ip->iflag & (IN_UPDATE | IN_CHANGE))
334 ip->iflag |= IN_MODIFIED;
335 ip->iflag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY);
336 }
337
338 /* chfs_update - updates a vnode times */
339 int
chfs_update(struct vnode * vp,const struct timespec * acc,const struct timespec * mod,int flags)340 chfs_update(struct vnode *vp, const struct timespec *acc,
341 const struct timespec *mod, int flags)
342 {
343 struct chfs_inode *ip;
344
345 /* XXX ufs_reclaim calls this function unlocked! */
346
347 ip = VTOI(vp);
348 chfs_itimes(ip, acc, mod, NULL);
349
350 return (0);
351 }
352
353