![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lfs_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / ufs / lfs|
Return to lfs_syscalls.c CVS log | Up to [Apple XNU] / XNU / bsd / ufs / lfs |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* $NetBSD: lfs_syscalls.c,v 1.8 1995/03/21 13:34:08 mycroft Exp $ */
23:
24: /*-
25: * Copyright (c) 1991, 1993, 1994
26: * The Regents of the University of California. All rights reserved.
27: *
28: * Redistribution and use in source and binary forms, with or without
29: * modification, are permitted provided that the following conditions
30: * are met:
31: * 1. Redistributions of source code must retain the above copyright
32: * notice, this list of conditions and the following disclaimer.
33: * 2. Redistributions in binary form must reproduce the above copyright
34: * notice, this list of conditions and the following disclaimer in the
35: * documentation and/or other materials provided with the distribution.
36: * 3. All advertising materials mentioning features or use of this software
37: * must display the following acknowledgement:
38: * This product includes software developed by the University of
39: * California, Berkeley and its contributors.
40: * 4. Neither the name of the University nor the names of its contributors
41: * may be used to endorse or promote products derived from this software
42: * without specific prior written permission.
43: *
44: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54: * SUCH DAMAGE.
55: *
56: * @(#)lfs_syscalls.c 8.6 (Berkeley) 6/16/94
57: */
58:
59: #include <sys/param.h>
60: #include <sys/systm.h>
61: #include <sys/proc.h>
62: #include <sys/buf.h>
63: #include <sys/mount.h>
64: #include <sys/vnode.h>
65: #include <sys/malloc.h>
66: #include <sys/kernel.h>
67:
68: #include <sys/syscallargs.h>
69:
70: #include <ufs/ufs/quota.h>
71: #include <ufs/ufs/inode.h>
72: #include <ufs/ufs/ufsmount.h>
73: #include <ufs/ufs/ufs_extern.h>
74:
75: #include <ufs/lfs/lfs.h>
76: #include <ufs/lfs/lfs_extern.h>
77: #define BUMP_FIP(SP) \
78: (SP)->fip = (FINFO *) (&(SP)->fip->fi_blocks[(SP)->fip->fi_nblocks])
79:
80: #define INC_FINFO(SP) ++((SEGSUM *)((SP)->segsum))->ss_nfinfo
81: #define DEC_FINFO(SP) --((SEGSUM *)((SP)->segsum))->ss_nfinfo
82:
83: /*
84: * Before committing to add something to a segment summary, make sure there
85: * is enough room. S is the bytes added to the summary.
86: */
87: #define CHECK_SEG(s) \
88: if (sp->sum_bytes_left < (s)) { \
89: (void) lfs_writeseg(fs, sp); \
90: }
91: struct buf *lfs_fakebuf __P((struct vnode *, int, size_t, caddr_t));
92:
93: /*
94: * lfs_markv:
95: *
96: * This will mark inodes and blocks dirty, so they are written into the log.
97: * It will block until all the blocks have been written. The segment create
98: * time passed in the block_info and inode_info structures is used to decide
99: * if the data is valid for each block (in case some process dirtied a block
100: * or inode that is being cleaned between the determination that a block is
101: * live and the lfs_markv call).
102: *
103: * 0 on success
104: * -1/errno is return on error.
105: */
106: int
107: lfs_markv(p, uap, retval)
108: struct proc *p;
109: struct lfs_markv_args /* {
110: syscallarg(fsid_t *) fsidp;
111: syscallarg(struct block_info *) blkiov;
112: syscallarg(int) blkcnt;
113: } */ *uap;
114: register_t *retval;
115: {
116: struct segment *sp;
117: BLOCK_INFO *blkp;
118: IFILE *ifp;
119: struct buf *bp, **bpp;
120: struct inode *ip;
121: struct lfs *fs;
122: struct mount *mntp;
123: struct vnode *vp;
124: fsid_t fsid;
125: void *start;
126: ino_t lastino;
127: daddr_t b_daddr, v_daddr;
128: u_long bsize;
129: int cnt, error;
130:
131: if (error = suser(p->p_ucred, &p->p_acflag))
132: return (error);
133:
134: if (error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t)))
135: return (error);
136: if ((mntp = getvfs(&fsid)) == NULL)
137: return (EINVAL);
138:
139: cnt = SCARG(uap, blkcnt);
140: // start = malloc(cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
141: MALLOC(start, void *, cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
142: if (error = copyin(SCARG(uap, blkiov), start, cnt * sizeof(BLOCK_INFO)))
143: goto err1;
144:
145: /* Mark blocks/inodes dirty. */
146: fs = VFSTOUFS(mntp)->um_lfs;
147: bsize = fs->lfs_bsize;
148: error = 0;
149:
150: lfs_seglock(fs, SEGM_SYNC | SEGM_CLEAN);
151: sp = fs->lfs_sp;
152: for (v_daddr = LFS_UNUSED_DADDR, lastino = LFS_UNUSED_INUM,
153: blkp = start; cnt--; ++blkp) {
154: /*
155: * Get the IFILE entry (only once) and see if the file still
156: * exists.
157: */
158: if (lastino != blkp->bi_inode) {
159: if (lastino != LFS_UNUSED_INUM) {
160: /* Finish up last file */
161: if (sp->fip->fi_nblocks == 0) {
162: DEC_FINFO(sp);
163: sp->sum_bytes_left +=
164: sizeof(FINFO) - sizeof(daddr_t);
165: } else {
166: lfs_updatemeta(sp);
167: BUMP_FIP(sp);
168: }
169:
170: lfs_writeinode(fs, sp, ip);
171: lfs_vunref(vp);
172: }
173:
174: /* Start a new file */
175: CHECK_SEG(sizeof(FINFO));
176: sp->sum_bytes_left -= sizeof(FINFO) - sizeof(daddr_t);
177: INC_FINFO(sp);
178: sp->start_lbp = &sp->fip->fi_blocks[0];
179: sp->vp = NULL;
180: sp->fip->fi_version = blkp->bi_version;
181: sp->fip->fi_nblocks = 0;
182: sp->fip->fi_ino = blkp->bi_inode;
183: lastino = blkp->bi_inode;
184: if (blkp->bi_inode == LFS_IFILE_INUM)
185: v_daddr = fs->lfs_idaddr;
186: else {
187: LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);
188: v_daddr = ifp->if_daddr;
189: brelse(bp);
190: }
191: if (v_daddr == LFS_UNUSED_DADDR)
192: continue;
193:
194: /* Get the vnode/inode. */
195: if (lfs_fastvget(mntp, blkp->bi_inode, v_daddr, &vp,
196: blkp->bi_lbn == LFS_UNUSED_LBN ?
197: blkp->bi_bp : NULL)) {
198: #if DIAGNOSTIC
199: printf("lfs_markv: VFS_VGET failed (%d)\n",
200: blkp->bi_inode);
201: #endif
202: lastino = LFS_UNUSED_INUM;
203: v_daddr = LFS_UNUSED_DADDR;
204: continue;
205: }
206: sp->vp = vp;
207: ip = VTOI(vp);
208: } else if (v_daddr == LFS_UNUSED_DADDR)
209: continue;
210:
211: /* If this BLOCK_INFO didn't contain a block, keep going. */
212: if (blkp->bi_lbn == LFS_UNUSED_LBN)
213: continue;
214: if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &b_daddr, NULL) ||
215: b_daddr != blkp->bi_daddr)
216: continue;
217: /*
218: * If we got to here, then we are keeping the block. If it
219: * is an indirect block, we want to actually put it in the
220: * buffer cache so that it can be updated in the finish_meta
221: * section. If it's not, we need to allocate a fake buffer
222: * so that writeseg can perform the copyin and write the buffer.
223: */
224: if (blkp->bi_lbn >= 0) /* Data Block */
225: bp = lfs_fakebuf(vp, blkp->bi_lbn, bsize,
226: blkp->bi_bp);
227: else {
228: bp = getblk(vp, blkp->bi_lbn, bsize, 0, 0);
229: if (!(bp->b_flags & (B_DELWRI | B_DONE | B_CACHE)) &&
230: (error = copyin(blkp->bi_bp, bp->b_data,
231: bsize)))
232: goto err2;
233: if (error = VOP_BWRITE(bp))
234: goto err2;
235: }
236: while (lfs_gatherblock(sp, bp, NULL));
237: }
238: if (sp->vp) {
239: if (sp->fip->fi_nblocks == 0) {
240: DEC_FINFO(sp);
241: sp->sum_bytes_left +=
242: sizeof(FINFO) - sizeof(daddr_t);
243: } else
244: lfs_updatemeta(sp);
245:
246: lfs_writeinode(fs, sp, ip);
247: lfs_vunref(vp);
248: }
249: (void) lfs_writeseg(fs, sp);
250: lfs_segunlock(fs);
251: free(start, M_SEGMENT);
252: return (error);
253:
254: /*
255: * XXX
256: * If we come in to error 2, we might have indirect blocks that were
257: * updated and now have bad block pointers. I don't know what to do
258: * about this.
259: */
260:
261: err2: lfs_vunref(vp);
262: /* Free up fakebuffers */
263: for (bpp = --sp->cbpp; bpp >= sp->bpp; --bpp)
264: if ((*bpp)->b_flags & B_CALL) {
265: brelvp(*bpp);
266: free(*bpp, M_SEGMENT);
267: } else
268: brelse(*bpp);
269: lfs_segunlock(fs);
270: err1:
271: free(start, M_SEGMENT);
272: return (error);
273: }
274:
275: /*
276: * lfs_bmapv:
277: *
278: * This will fill in the current disk address for arrays of blocks.
279: *
280: * 0 on success
281: * -1/errno is return on error.
282: */
283: int
284: lfs_bmapv(p, uap, retval)
285: struct proc *p;
286: struct lfs_bmapv_args /* {
287: syscallarg(fsid_t *) fsidp;
288: syscallarg(struct block_info *) blkiov;
289: syscallarg(int) blkcnt;
290: } */ *uap;
291: register_t *retval;
292: {
293: BLOCK_INFO *blkp;
294: struct mount *mntp;
295: struct vnode *vp;
296: fsid_t fsid;
297: void *start;
298: daddr_t daddr;
299: int cnt, error, step;
300:
301: if (error = suser(p->p_ucred, &p->p_acflag))
302: return (error);
303:
304: if (error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t)))
305: return (error);
306: if ((mntp = getvfs(&fsid)) == NULL)
307: return (EINVAL);
308:
309: cnt = SCARG(uap, blkcnt);
310: // start = blkp = malloc(cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
311: MALLOC(blkp, BLOCK_INFO *, cnt * sizeof(BLOCK_INFO), M_SEGMENT, M_WAITOK);
312: start = blkp;
313: if (error = copyin(SCARG(uap, blkiov), blkp,
314: cnt * sizeof(BLOCK_INFO))) {
315: free(blkp, M_SEGMENT);
316: return (error);
317: }
318:
319: for (step = cnt; step--; ++blkp) {
320: if (blkp->bi_lbn == LFS_UNUSED_LBN)
321: continue;
322: /* Could be a deadlock ? */
323: if (VFS_VGET(mntp, blkp->bi_inode, &vp))
324: daddr = LFS_UNUSED_DADDR;
325: else {
326: if (VOP_BMAP(vp, blkp->bi_lbn, NULL, &daddr, NULL))
327: daddr = LFS_UNUSED_DADDR;
328: vput(vp);
329: }
330: blkp->bi_daddr = daddr;
331: }
332: copyout(start, SCARG(uap, blkiov), cnt * sizeof(BLOCK_INFO));
333: free(start, M_SEGMENT);
334: return (0);
335: }
336:
337: /*
338: * lfs_segclean:
339: *
340: * Mark the segment clean.
341: *
342: * 0 on success
343: * -1/errno is return on error.
344: */
345: int
346: lfs_segclean(p, uap, retval)
347: struct proc *p;
348: struct lfs_segclean_args /* {
349: syscallarg(fsid_t *) fsidp;
350: syscallarg(u_long) segment;
351: } */ *uap;
352: register_t *retval;
353: {
354: CLEANERINFO *cip;
355: SEGUSE *sup;
356: struct buf *bp;
357: struct mount *mntp;
358: struct lfs *fs;
359: fsid_t fsid;
360: int error;
361:
362: if (error = suser(p->p_ucred, &p->p_acflag))
363: return (error);
364:
365: if (error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t)))
366: return (error);
367: if ((mntp = getvfs(&fsid)) == NULL)
368: return (EINVAL);
369:
370: fs = VFSTOUFS(mntp)->um_lfs;
371:
372: if (datosn(fs, fs->lfs_curseg) == SCARG(uap, segment))
373: return (EBUSY);
374:
375: LFS_SEGENTRY(sup, fs, SCARG(uap, segment), bp);
376: if (sup->su_flags & SEGUSE_ACTIVE) {
377: brelse(bp);
378: return (EBUSY);
379: }
380: fs->lfs_avail += fsbtodb(fs, fs->lfs_ssize) - 1;
381: fs->lfs_bfree += (sup->su_nsums * LFS_SUMMARY_SIZE / DEV_BSIZE) +
382: sup->su_ninos * btodb(fs->lfs_bsize);
383: sup->su_flags &= ~SEGUSE_DIRTY;
384: (void) VOP_BWRITE(bp);
385:
386: LFS_CLEANERINFO(cip, fs, bp);
387: ++cip->clean;
388: --cip->dirty;
389: (void) VOP_BWRITE(bp);
390: wakeup(&fs->lfs_avail);
391: return (0);
392: }
393:
394: /*
395: * lfs_segwait:
396: *
397: * This will block until a segment in file system fsid is written. A timeout
398: * in milliseconds may be specified which will awake the cleaner automatically.
399: * An fsid of -1 means any file system, and a timeout of 0 means forever.
400: *
401: * 0 on success
402: * 1 on timeout
403: * -1/errno is return on error.
404: */
405: int
406: lfs_segwait(p, uap, retval)
407: struct proc *p;
408: struct lfs_segwait_args /* {
409: syscallarg(fsid_t *) fsidp;
410: syscallarg(struct timeval *) tv;
411: } */ *uap;
412: register_t *retval;
413: {
414: extern int lfs_allclean_wakeup;
415: struct mount *mntp;
416: struct timeval atv;
417: fsid_t fsid;
418: void *addr;
419: u_long timeout;
420: int error, s;
421:
422: if (error = suser(p->p_ucred, &p->p_acflag)) {
423: return (error);
424: }
425: #ifdef WHEN_QUADS_WORK
426: if (error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t)))
427: return (error);
428: if (fsid == (fsid_t)-1)
429: addr = &lfs_allclean_wakeup;
430: else {
431: if ((mntp = getvfs(&fsid)) == NULL)
432: return (EINVAL);
433: addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg;
434: }
435: #else
436: if (error = copyin(SCARG(uap, fsidp), &fsid, sizeof(fsid_t)))
437: return (error);
438: if ((mntp = getvfs(&fsid)) == NULL)
439: addr = &lfs_allclean_wakeup;
440: else
441: addr = &VFSTOUFS(mntp)->um_lfs->lfs_nextseg;
442: #endif
443:
444: if (SCARG(uap, tv)) {
445: if (error =
446: copyin(SCARG(uap, tv), &atv, sizeof(struct timeval)))
447: return (error);
448: if (itimerfix(&atv))
449: return (EINVAL);
450: s = splclock();
451: timeradd(&atv, &time, &atv);
452: timeout = hzto(&atv);
453: splx(s);
454: } else
455: timeout = 0;
456:
457: error = tsleep(addr, PCATCH | PUSER, "segment", timeout);
458: return (error == ERESTART ? EINTR : 0);
459: }
460:
461: /*
462: * VFS_VGET call specialized for the cleaner. The cleaner already knows the
463: * daddr from the ifile, so don't look it up again. If the cleaner is
464: * processing IINFO structures, it may have the ondisk inode already, so
465: * don't go retrieving it again.
466: */
467: int
468: lfs_fastvget(mp, ino, daddr, vpp, dinp)
469: struct mount *mp;
470: ino_t ino;
471: daddr_t daddr;
472: struct vnode **vpp;
473: struct dinode *dinp;
474: {
475: register struct inode *ip;
476: struct vnode *vp;
477: struct ufsmount *ump;
478: struct buf *bp;
479: dev_t dev;
480: int error;
481:
482: ump = VFSTOUFS(mp);
483: dev = ump->um_dev;
484: /*
485: * This is playing fast and loose. Someone may have the inode
486: * locked, in which case they are going to be distinctly unhappy
487: * if we trash something.
488: */
489: if ((*vpp = ufs_ihashlookup(dev, ino)) != NULL) {
490: lfs_vref(*vpp);
491: if ((*vpp)->v_flag & VXLOCK)
492: printf ("Cleaned vnode VXLOCKED\n");
493: ip = VTOI(*vpp);
494: if (ip->i_flag & IN_LOCKED)
495: printf("cleaned vnode locked\n");
496: if (!(ip->i_flag & IN_MODIFIED)) {
497: ++ump->um_lfs->lfs_uinodes;
498: ip->i_flag |= IN_MODIFIED;
499: }
500: ip->i_flag |= IN_MODIFIED;
501: return (0);
502: }
503:
504: /* Allocate new vnode/inode. */
505: if (error = lfs_vcreate(mp, ino, &vp)) {
506: *vpp = NULL;
507: return (error);
508: }
509:
510: /*
511: * Put it onto its hash chain and lock it so that other requests for
512: * this inode will block if they arrive while we are sleeping waiting
513: * for old data structures to be purged or for the contents of the
514: * disk portion of this inode to be read.
515: */
516: ip = VTOI(vp);
517: ufs_ihashins(ip);
518:
519: /*
520: * XXX
521: * This may not need to be here, logically it should go down with
522: * the i_devvp initialization.
523: * Ask Kirk.
524: */
525: ip->i_lfs = ump->um_lfs;
526:
527: /* Read in the disk contents for the inode, copy into the inode. */
528: if (dinp)
529: if (error = copyin(dinp, &ip->i_din, sizeof(struct dinode)))
530: return (error);
531: else {
532: if (error = bread(ump->um_devvp, daddr,
533: (int)ump->um_lfs->lfs_bsize, NOCRED, &bp)) {
534: /*
535: * The inode does not contain anything useful, so it
536: * would be misleading to leave it on its hash chain.
537: * Iput() will return it to the free list.
538: */
539: ufs_ihashrem(ip);
540:
541: /* Unlock and discard unneeded inode. */
542: lfs_vunref(vp);
543: brelse(bp);
544: *vpp = NULL;
545: return (error);
546: }
547: ip->i_din =
548: *lfs_ifind(ump->um_lfs, ino, (struct dinode *)bp->b_data);
549: brelse(bp);
550: }
551:
552: /* Inode was just read from user space or disk, make sure it's locked */
553: ip->i_flag |= IN_LOCKED;
554:
555: /*
556: * Initialize the vnode from the inode, check for aliases. In all
557: * cases re-init ip, the underlying vnode/inode may have changed.
558: */
559: if (error = ufs_vinit(mp, lfs_specop_p, LFS_FIFOOPS, &vp)) {
560: lfs_vunref(vp);
561: *vpp = NULL;
562: return (error);
563: }
564: /*
565: * Finish inode initialization now that aliasing has been resolved.
566: */
567: ip->i_devvp = ump->um_devvp;
568: ip->i_flag |= IN_MODIFIED;
569: ++ump->um_lfs->lfs_uinodes;
570: VREF(ip->i_devvp);
571: *vpp = vp;
572: return (0);
573: }
574: struct buf *
575: lfs_fakebuf(vp, lbn, size, uaddr)
576: struct vnode *vp;
577: int lbn;
578: size_t size;
579: caddr_t uaddr;
580: {
581: struct buf *bp;
582:
583: bp = lfs_newbuf(vp, lbn, 0);
584: bp->b_saveaddr = uaddr;
585: bp->b_bufsize = size;
586: bp->b_bcount = size;
587: bp->b_flags |= B_INVAL;
588: return (bp);
589: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.