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