1 /* 2 * Copyright (c) 1989, 1990, 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)mfs_vfsops.c 8.11 (Berkeley) 6/19/95 34 * $FreeBSD: src/sys/ufs/mfs/mfs_vfsops.c,v 1.81.2.3 2001/07/04 17:35:21 tegge Exp $ 35 * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.28 2006/04/02 01:35:34 dillon Exp $ 36 */ 37 38 39 #include "opt_mfs.h" 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/conf.h> 44 #include <sys/kernel.h> 45 #include <sys/proc.h> 46 #include <sys/buf.h> 47 #include <sys/mount.h> 48 #include <sys/signalvar.h> 49 #include <sys/vnode.h> 50 #include <sys/malloc.h> 51 #include <sys/linker.h> 52 #include <sys/fcntl.h> 53 54 #include <vm/vm.h> 55 #include <vm/vm_object.h> 56 #include <vm/vm_page.h> 57 #include <vm/vm_pager.h> 58 #include <vm/vnode_pager.h> 59 60 #include <sys/buf2.h> 61 #include <sys/thread2.h> 62 63 #include <vfs/ufs/quota.h> 64 #include <vfs/ufs/inode.h> 65 #include <vfs/ufs/ufsmount.h> 66 #include <vfs/ufs/ufs_extern.h> 67 #include <vfs/ufs/fs.h> 68 #include <vfs/ufs/ffs_extern.h> 69 70 #include "mfsnode.h" 71 #include "mfs_extern.h" 72 73 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part"); 74 75 76 extern struct vop_ops *mfs_vnode_vops; 77 78 static int mfs_mount (struct mount *mp, 79 char *path, caddr_t data, struct thread *td); 80 static int mfs_start (struct mount *mp, int flags, struct thread *td); 81 static int mfs_statfs (struct mount *mp, struct statfs *sbp, 82 struct thread *td); 83 static int mfs_init (struct vfsconf *); 84 85 d_open_t mfsopen; 86 d_close_t mfsclose; 87 d_strategy_t mfsstrategy; 88 89 #define MFS_CDEV_MAJOR 253 90 91 static struct cdevsw mfs_cdevsw = { 92 /* name */ "MFS", 93 /* maj */ MFS_CDEV_MAJOR, 94 /* flags */ D_DISK, 95 /* port */ NULL, 96 /* clone */ NULL, 97 98 /* open */ mfsopen, 99 /* close */ mfsclose, 100 /* read */ physread, 101 /* write */ physwrite, 102 /* ioctl */ noioctl, 103 /* poll */ nopoll, 104 /* mmap */ nommap, 105 /* strategy */ mfsstrategy, 106 /* dump */ nodump, 107 /* psize */ nopsize 108 }; 109 110 /* 111 * mfs vfs operations. 112 */ 113 static struct vfsops mfs_vfsops = { 114 .vfs_mount = mfs_mount, 115 .vfs_start = mfs_start, 116 .vfs_unmount = ffs_unmount, 117 .vfs_root = ufs_root, 118 .vfs_quotactl = ufs_quotactl, 119 .vfs_statfs = mfs_statfs, 120 .vfs_sync = ffs_sync, 121 .vfs_vget = ffs_vget, 122 .vfs_fhtovp = ffs_fhtovp, 123 .vfs_checkexp = ufs_check_export, 124 .vfs_vptofh = ffs_vptofh, 125 .vfs_init = mfs_init 126 }; 127 128 VFS_SET(mfs_vfsops, mfs, 0); 129 130 /* 131 * We allow the underlying MFS block device to be opened and read. 132 */ 133 int 134 mfsopen(dev_t dev, int flags, int mode, struct thread *td) 135 { 136 if (flags & FWRITE) 137 return(EROFS); 138 if (dev->si_drv1) 139 return(0); 140 return(ENXIO); 141 } 142 143 int 144 mfsclose(dev_t dev, int flags, int mode, struct thread *td) 145 { 146 return(0); 147 } 148 149 void 150 mfsstrategy(dev_t dev, struct bio *bio) 151 { 152 struct buf *bp = bio->bio_buf; 153 struct mfsnode *mfsp; 154 155 if ((mfsp = dev->si_drv1) != NULL) { 156 off_t boff = bio->bio_offset; 157 off_t eoff = boff + bp->b_bcount; 158 159 if (boff < 0) { 160 bp->b_error = EINVAL; 161 biodone(bio); 162 } else if (eoff <= mfsp->mfs_size) { 163 bioq_insert_tail(&mfsp->bio_queue, bio); 164 wakeup((caddr_t)mfsp); 165 } else if (boff < mfsp->mfs_size) { 166 bp->b_bcount = mfsp->mfs_size - boff; 167 bioq_insert_tail(&mfsp->bio_queue, bio); 168 wakeup((caddr_t)mfsp); 169 } else if (boff == mfsp->mfs_size) { 170 bp->b_resid = bp->b_bcount; 171 biodone(bio); 172 } else { 173 bp->b_error = EINVAL; 174 biodone(bio); 175 } 176 } else { 177 bp->b_error = ENXIO; 178 bp->b_flags |= B_ERROR; 179 biodone(bio); 180 } 181 } 182 183 /* 184 * mfs_mount 185 * 186 * Called when mounting local physical media 187 * 188 * PARAMETERS: 189 * mountroot 190 * mp mount point structure 191 * path NULL (flag for root mount!!!) 192 * data <unused> 193 * ndp <unused> 194 * p process (user credentials check [statfs]) 195 * 196 * mount 197 * mp mount point structure 198 * path path to mount point 199 * data pointer to argument struct in user space 200 * ndp mount point namei() return (used for 201 * credentials on reload), reused to look 202 * up block device. 203 * p process (user credentials check) 204 * 205 * RETURNS: 0 Success 206 * !0 error number (errno.h) 207 * 208 * LOCK STATE: 209 * 210 * ENTRY 211 * mount point is locked 212 * EXIT 213 * mount point is locked 214 * 215 * NOTES: 216 * A NULL path can be used for a flag since the mount 217 * system call will fail with EFAULT in copyinstr in 218 * namei() if it is a genuine NULL from the user. 219 */ 220 /* ARGSUSED */ 221 static int 222 mfs_mount(struct mount *mp, char *path, caddr_t data, struct thread *td) 223 { 224 struct vnode *devvp; 225 struct mfs_args args; 226 struct ufsmount *ump; 227 struct fs *fs; 228 struct mfsnode *mfsp; 229 size_t size; 230 int flags, err; 231 int minnum; 232 dev_t dev; 233 234 /* 235 * Use NULL path to flag a root mount 236 */ 237 if( path == NULL) { 238 /* 239 *** 240 * Mounting root file system 241 *** 242 */ 243 244 /* you lose */ 245 panic("mfs_mount: mount MFS as root: not configured!"); 246 } 247 248 /* 249 *** 250 * Mounting non-root file system or updating a file system 251 *** 252 */ 253 254 /* copy in user arguments*/ 255 if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0) 256 goto error_1; 257 258 /* 259 * If updating, check whether changing from read-only to 260 * read/write; if there is no device name, that's all we do. 261 */ 262 if (mp->mnt_flag & MNT_UPDATE) { 263 /* 264 ******************** 265 * UPDATE 266 ******************** 267 */ 268 ump = VFSTOUFS(mp); 269 fs = ump->um_fs; 270 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { 271 flags = WRITECLOSE; 272 if (mp->mnt_flag & MNT_FORCE) 273 flags |= FORCECLOSE; 274 err = ffs_flushfiles(mp, flags, td); 275 if (err) 276 goto error_1; 277 } 278 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) { 279 /* XXX reopen the device vnode read-write */ 280 fs->fs_ronly = 0; 281 } 282 /* if not updating name...*/ 283 if (args.fspec == 0) { 284 /* 285 * Process export requests. Jumping to "success" 286 * will return the vfs_export() error code. 287 */ 288 err = vfs_export(mp, &ump->um_export, &args.export); 289 goto success; 290 } 291 292 /* XXX MFS does not support name updating*/ 293 goto success; 294 } 295 /* 296 * Do the MALLOC before the getnewvnode since doing so afterward 297 * might cause a bogus v_data pointer to get dereferenced 298 * elsewhere if MALLOC should block. 299 */ 300 MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK); 301 302 err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops, &devvp, 0, 0); 303 if (err) { 304 FREE(mfsp, M_MFSNODE); 305 goto error_1; 306 } 307 308 minnum = (curproc->p_pid & 0xFF) | 309 ((curproc->p_pid & ~0xFF) << 8); 310 311 devvp->v_type = VCHR; 312 dev = make_dev(&mfs_cdevsw, minnum, UID_ROOT, GID_WHEEL, 0600, 313 "MFS%d", minnum >> 16); 314 /* It is not clear that these will get initialized otherwise */ 315 dev->si_bsize_phys = DEV_BSIZE; 316 dev->si_iosize_max = DFLTPHYS; 317 dev->si_drv1 = mfsp; 318 addaliasu(devvp, makeudev(MFS_CDEV_MAJOR, minnum)); 319 devvp->v_data = mfsp; 320 mfsp->mfs_baseoff = args.base; 321 mfsp->mfs_size = args.size; 322 mfsp->mfs_vnode = devvp; 323 mfsp->mfs_dev = reference_dev(dev); 324 mfsp->mfs_td = td; 325 mfsp->mfs_active = 1; 326 bioq_init(&mfsp->bio_queue); 327 328 /* 329 * Our 'block' device must be backed by a VM object. Theoretically 330 * we could use the anonymous memory VM object supplied by userland, 331 * but it would be somewhat of a complex task to deal with it 332 * that way since it would result in I/O requests which supply 333 * the VM pages from our own object. 334 * 335 * vnode_pager_alloc() is typically called when a VM object is 336 * being referenced externally. We have to undo the refs for 337 * the self reference between vnode and object. 338 */ 339 vnode_pager_alloc(devvp, args.size, 0, 0); 340 --devvp->v_usecount; 341 --devvp->v_object->ref_count; 342 343 /* Save "mounted from" info for mount point (NULL pad)*/ 344 copyinstr( args.fspec, /* device name*/ 345 mp->mnt_stat.f_mntfromname, /* save area*/ 346 MNAMELEN - 1, /* max size*/ 347 &size); /* real size*/ 348 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); 349 350 vx_unlock(devvp); 351 if ((err = ffs_mountfs(devvp, mp, td, M_MFSNODE)) != 0) { 352 mfsp->mfs_active = 0; 353 goto error_2; 354 } 355 356 /* 357 * Initialize FS stat information in mount struct; uses 358 * mp->mnt_stat.f_mntfromname. 359 * 360 * This code is common to root and non-root mounts 361 */ 362 VFS_STATFS(mp, &mp->mnt_stat, td); 363 364 goto success; 365 366 error_2: /* error with devvp held*/ 367 368 /* release devvp before failing*/ 369 vrele(devvp); 370 371 error_1: /* no state to back out*/ 372 373 success: 374 return( err); 375 } 376 377 /* 378 * Used to grab the process and keep it in the kernel to service 379 * memory filesystem I/O requests. 380 * 381 * Loop servicing I/O requests. 382 * Copy the requested data into or out of the memory filesystem 383 * address space. 384 */ 385 /* ARGSUSED */ 386 static int 387 mfs_start(struct mount *mp, int flags, struct thread *td) 388 { 389 struct vnode *vp = VFSTOUFS(mp)->um_devvp; 390 struct mfsnode *mfsp = VTOMFS(vp); 391 struct bio *bio; 392 struct buf *bp; 393 int gotsig = 0, sig; 394 395 /* 396 * We must prevent the system from trying to swap 397 * out or kill ( when swap space is low, see vm/pageout.c ) the 398 * process. A deadlock can occur if the process is swapped out, 399 * and the system can loop trying to kill the unkillable ( while 400 * references exist ) MFS process when swap space is low. 401 */ 402 KKASSERT(curproc); 403 PHOLD(curproc); 404 405 while (mfsp->mfs_active) { 406 crit_enter(); 407 408 while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) { 409 bioq_remove(&mfsp->bio_queue, bio); 410 crit_exit(); 411 bp = bio->bio_buf; 412 mfs_doio(bio, mfsp); 413 wakeup(bp); 414 crit_enter(); 415 } 416 417 crit_exit(); 418 419 /* 420 * If a non-ignored signal is received, try to unmount. 421 * If that fails, clear the signal (it has been "processed"), 422 * otherwise we will loop here, as tsleep will always return 423 * EINTR/ERESTART. 424 */ 425 /* 426 * Note that dounmount() may fail if work was queued after 427 * we slept. We have to jump hoops here to make sure that we 428 * process any buffers after the sleep, before we dounmount() 429 */ 430 if (gotsig) { 431 gotsig = 0; 432 if (dounmount(mp, 0, td) != 0) { 433 KKASSERT(td->td_proc); 434 sig = CURSIG(td->td_proc); 435 if (sig) 436 SIGDELSET(td->td_proc->p_siglist, sig); 437 } 438 } 439 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0)) 440 gotsig++; /* try to unmount in next pass */ 441 } 442 PRELE(curproc); 443 v_release_rdev(vp); /* hack because we do not implement CLOSE */ 444 /* XXX destroy/release devvp */ 445 return (0); 446 } 447 448 /* 449 * Get file system statistics. 450 */ 451 static int 452 mfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td) 453 { 454 int error; 455 456 error = ffs_statfs(mp, sbp, td); 457 sbp->f_type = mp->mnt_vfc->vfc_typenum; 458 return (error); 459 } 460 461 /* 462 * Memory based filesystem initialization. 463 */ 464 static int 465 mfs_init(struct vfsconf *vfsp) 466 { 467 cdevsw_add(&mfs_cdevsw, 0, 0); 468 return (0); 469 } 470