?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / fs / udf / udf_vnops.c
blob5fb5a35040a5dccf7a78433c3f3075915cff4f29
1 /* $NetBSD: udf_vnops.c,v 1.56 2010/01/05 13:30:11 mbalmer Exp $ */
2
3 /*
4 * Copyright (c) 2006, 2008 Reinoud Zandijk
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * Generic parts are derived from software contributed to The NetBSD Foundation
28 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
29 * 2005 program.
30 *
31 */
32
33 #include <sys/cdefs.h>
34 #ifndef lint
35 __KERNEL_RCSID(0, "$NetBSD: udf_vnops.c,v 1.56 2010/01/05 13:30:11 mbalmer Exp $");
36 #endif /* not lint */
37
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/namei.h>
42 #include <sys/resourcevar.h> /* defines plimit structure in proc struct */
43 #include <sys/kernel.h>
44 #include <sys/file.h> /* define FWRITE ... */
45 #include <sys/stat.h>
46 #include <sys/buf.h>
47 #include <sys/proc.h>
48 #include <sys/mount.h>
49 #include <sys/vnode.h>
50 #include <sys/signalvar.h>
51 #include <sys/malloc.h>
52 #include <sys/dirent.h>
53 #include <sys/lockf.h>
54 #include <sys/kauth.h>
55
56 #include <miscfs/genfs/genfs.h>
57 #include <uvm/uvm_extern.h>
58
59 #include <fs/udf/ecma167-udf.h>
60 #include <fs/udf/udf_mount.h>
61 #include "udf.h"
62 #include "udf_subr.h"
63 #include "udf_bswap.h"
64
65
66 #define VTOI(vnode) ((struct udf_node *) (vnode)->v_data)
67
68
69 /* externs */
70 extern int prtactive;
71
72 /* implementations of vnode functions; table follows at end */
73 /* --------------------------------------------------------------------- */
74
75 int
76 udf_inactive(void *v)
77 {
78 struct vop_inactive_args /* {
79 struct vnode *a_vp;
80 bool *a_recycle;
81 } */ *ap = v;
82 struct vnode *vp = ap->a_vp;
83 struct udf_node *udf_node = VTOI(vp);
84 int refcnt;
85
86 DPRINTF(NODE, ("udf_inactive called for udf_node %p\n", VTOI(vp)));
87
88 if (udf_node == NULL) {
89 DPRINTF(NODE, ("udf_inactive: inactive NULL UDF node\n"));
90 VOP_UNLOCK(vp, 0);
91 return 0;
92 }
93
94 /*
95 * Optionally flush metadata to disc. If the file has not been
96 * referenced anymore in a directory we ought to free up the resources
97 * on disc if applicable.
98 */
99 if (udf_node->fe) {
100 refcnt = udf_rw16(udf_node->fe->link_cnt);
101 } else {
102 assert(udf_node->efe);
103 refcnt = udf_rw16(udf_node->efe->link_cnt);
104 }
105
106 if ((refcnt == 0) && (vp->v_vflag & VV_SYSTEM)) {
107 DPRINTF(VOLUMES, ("UDF_INACTIVE deleting VV_SYSTEM\n"));
108 /* system nodes are not writen out on inactive, so flush */
109 udf_node->i_flags = 0;
110 }
111
112 *ap->a_recycle = false;
113 if ((refcnt == 0) && ((vp->v_vflag & VV_SYSTEM) == 0)) {
114 /* remove this file's allocation */
115 DPRINTF(NODE, ("udf_inactive deleting unlinked file\n"));
116 *ap->a_recycle = true;
117 udf_delete_node(udf_node);
118 VOP_UNLOCK(vp, 0);
119 vrecycle(vp, NULL, curlwp);
120 return 0;
121 }
122
123 /* write out its node */
124 if (udf_node->i_flags & (IN_CHANGE | IN_UPDATE | IN_MODIFIED))
125 udf_update(vp, NULL, NULL, NULL, 0);
126 VOP_UNLOCK(vp, 0);
127
128 return 0;
129 }
130
131 /* --------------------------------------------------------------------- */
132
133 int udf_sync(struct mount *mp, int waitfor, kauth_cred_t cred, struct lwp *lwp);
134
135 int
136 udf_reclaim(void *v)
137 {
138 struct vop_reclaim_args /* {
139 struct vnode *a_vp;
140 } */ *ap = v;
141 struct vnode *vp = ap->a_vp;
142 struct udf_node *udf_node = VTOI(vp);
143
144 DPRINTF(NODE, ("udf_reclaim called for node %p\n", udf_node));
145 if (prtactive && vp->v_usecount > 1)
146 vprint("udf_reclaim(): pushing active", vp);
147
148 if (udf_node == NULL) {
149 DPRINTF(NODE, ("udf_reclaim(): null udfnode\n"));
150 return 0;
151 }
152
153 /* update note for closure */
154 udf_update(vp, NULL, NULL, NULL, UPDATE_CLOSE);
155
156 /* async check to see if all node descriptors are written out */
157 while ((volatile int) udf_node->outstanding_nodedscr > 0) {
158 vprint("udf_reclaim(): waiting for writeout\n", vp);
159 tsleep(&udf_node->outstanding_nodedscr, PRIBIO, "recl wait", hz/8);
160 }
161
162 /* purge old data from namei */
163 cache_purge(vp);
164
165 /* dispose all node knowledge */
166 udf_dispose_node(udf_node);
167
168 return 0;
169 }
170
171 /* --------------------------------------------------------------------- */
172
173 int
174 udf_read(void *v)
175 {
176 struct vop_read_args /* {
177 struct vnode *a_vp;
178 struct uio *a_uio;
179 int a_ioflag;
180 kauth_cred_t a_cred;
181 } */ *ap = v;
182 struct vnode *vp = ap->a_vp;
183 struct uio *uio = ap->a_uio;
184 int ioflag = ap->a_ioflag;
185 int advice = IO_ADV_DECODE(ap->a_ioflag);
186 struct uvm_object *uobj;
187 struct udf_node *udf_node = VTOI(vp);
188 struct file_entry *fe;
189 struct extfile_entry *efe;
190 uint64_t file_size;
191 vsize_t len;
192 int error;
193
194 /*
195 * XXX reading from extended attributes not yet implemented. FreeBSD
196 * has it in mind to forward the IO_EXT read call to the
197 * VOP_READEXTATTR().
198 */
199
200 DPRINTF(READ, ("udf_read called\n"));
201
202 /* can this happen? some filingsystems have this check */
203 if (uio->uio_offset < 0)
204 return EINVAL;
205 if (uio->uio_resid == 0)
206 return 0;
207
208 /* protect against rogue programs reading raw directories and links */
209 if ((ioflag & IO_ALTSEMANTICS) == 0) {
210 if (vp->v_type == VDIR)
211 return EISDIR;
212 /* all but regular files just give EINVAL */
213 if (vp->v_type != VREG)
214 return EINVAL;
215 }
216
217 assert(udf_node);
218 assert(udf_node->fe || udf_node->efe);
219
220 /* get file/directory filesize */
221 if (udf_node->fe) {
222 fe = udf_node->fe;
223 file_size = udf_rw64(fe->inf_len);
224 } else {
225 assert(udf_node->efe);
226 efe = udf_node->efe;
227 file_size = udf_rw64(efe->inf_len);
228 }
229
230 /* read contents using buffercache */
231 uobj = &vp->v_uobj;
232 error = 0;
233 while (uio->uio_resid > 0) {
234 /* reached end? */
235 if (file_size <= uio->uio_offset)
236 break;
237
238 /* maximise length to file extremity */
239 len = MIN(file_size - uio->uio_offset, uio->uio_resid);
240 if (len == 0)
241 break;
242
243 /* ubc, here we come, prepare to trap */
244 error = ubc_uiomove(uobj, uio, len, advice,
245 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp));
246 if (error)
247 break;
248 }
249
250 /* note access time unless not requested */
251 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) {
252 udf_node->i_flags |= IN_ACCESS;
253 if ((ioflag & IO_SYNC) == IO_SYNC)
254 error = udf_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
255 }
256
257 return error;
258 }
259
260 /* --------------------------------------------------------------------- */
261
262 int
263 udf_write(void *v)
264 {
265 struct vop_write_args /* {
266 struct vnode *a_vp;
267 struct uio *a_uio;
268 int a_ioflag;
269 kauth_cred_t a_cred;
270 } */ *ap = v;
271 struct vnode *vp = ap->a_vp;
272 struct uio *uio = ap->a_uio;
273 int ioflag = ap->a_ioflag;
274 kauth_cred_t cred = ap->a_cred;
275 int advice = IO_ADV_DECODE(ap->a_ioflag);
276 struct uvm_object *uobj;
277 struct udf_node *udf_node = VTOI(vp);
278 struct file_entry *fe;
279 struct extfile_entry *efe;
280 uint64_t file_size, old_size, old_offset;
281 vsize_t len;
282 int async = vp->v_mount->mnt_flag & MNT_ASYNC;
283 int aflag = ioflag & IO_SYNC ? B_SYNC : 0;
284 int error;
285 int resid, extended;
286
287 /*
288 * XXX writing to extended attributes not yet implemented. FreeBSD has
289 * it in mind to forward the IO_EXT read call to the
290 * VOP_READEXTATTR().
291 */
292
293 DPRINTF(WRITE, ("udf_write called\n"));
294
295 /* can this happen? some filingsystems have this check */
296 if (uio->uio_offset < 0)
297 return EINVAL;
298 if (uio->uio_resid == 0)
299 return 0;
300
301 /* protect against rogue programs writing raw directories or links */
302 if ((ioflag & IO_ALTSEMANTICS) == 0) {
303 if (vp->v_type == VDIR)
304 return EISDIR;
305 /* all but regular files just give EINVAL for now */
306 if (vp->v_type != VREG)
307 return EINVAL;
308 }
309
310 assert(udf_node);
311 assert(udf_node->fe || udf_node->efe);
312
313 /* get file/directory filesize */
314 if (udf_node->fe) {
315 fe = udf_node->fe;
316 file_size = udf_rw64(fe->inf_len);
317 } else {
318 assert(udf_node->efe);
319 efe = udf_node->efe;
320 file_size = udf_rw64(efe->inf_len);
321 }
322 old_size = file_size;
323
324 /* if explicitly asked to append, uio_offset can be wrong? */
325 if (ioflag & IO_APPEND)
326 uio->uio_offset = file_size;
327
328 extended = (uio->uio_offset + uio->uio_resid > file_size);
329 if (extended) {
330 DPRINTF(WRITE, ("extending file from %"PRIu64" to %"PRIu64"\n",
331 file_size, uio->uio_offset + uio->uio_resid));
332 error = udf_grow_node(udf_node, uio->uio_offset + uio->uio_resid);
333 if (error)
334 return error;
335 file_size = uio->uio_offset + uio->uio_resid;
336 }
337
338 /* write contents using buffercache */
339 uobj = &vp->v_uobj;
340 resid = uio->uio_resid;
341 error = 0;
342
343 uvm_vnp_setwritesize(vp, file_size);
344 old_offset = uio->uio_offset;
345 while (uio->uio_resid > 0) {
346 /* maximise length to file extremity */
347 len = MIN(file_size - uio->uio_offset, uio->uio_resid);
348 if (len == 0)
349 break;
350
351 genfs_node_wrlock(vp);
352 error = GOP_ALLOC(vp, uio->uio_offset, len, aflag, cred);
353 genfs_node_unlock(vp);
354 if (error)
355 break;
356
357 /* ubc, here we come, prepare to trap */
358 error = ubc_uiomove(uobj, uio, len, advice,
359 UBC_WRITE | UBC_UNMAP_FLAG(vp));
360 if (error)
361 break;
362
363 /*
364 * flush what we just wrote if necessary.
365 * XXXUBC simplistic async flushing.
366 *
367 * Directories are excluded since its file data that we want
368 * to purge.
369 */
370 if (!async && (vp->v_type != VDIR) &&
371 (old_offset >> 16 != uio->uio_offset >> 16)) {
372 mutex_enter(&vp->v_interlock);
373 error = VOP_PUTPAGES(vp, (old_offset >> 16) << 16,
374 (uio->uio_offset >> 16) << 16, PGO_CLEANIT);
375 old_offset = uio->uio_offset;
376 }
377 }
378 uvm_vnp_setsize(vp, file_size);
379
380 /* mark node changed and request update */
381 udf_node->i_flags |= IN_CHANGE | IN_UPDATE;
382
383 /*
384 * XXX TODO FFS has code here to reset setuid & setgid when we're not
385 * the superuser as a precaution against tampering.
386 */
387
388 /* if we wrote a thing, note write action on vnode */
389 if (resid > uio->uio_resid)
390 VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
391
392 if (error) {
393 /* bring back file size to its former size */
394 /* take notice of its errors? */
395 (void) udf_chsize(vp, (u_quad_t) old_size, cred);
396
397 /* roll back uio */
398 uio->uio_offset -= resid - uio->uio_resid;
399 uio->uio_resid = resid;
400 } else {
401 /* if we write and we're synchronous, update node */
402 if ((resid > uio->uio_resid) && ((ioflag & IO_SYNC) == IO_SYNC))
403 error = udf_update(vp, NULL, NULL, NULL, UPDATE_WAIT);
404 }
405
406 return error;
407 }
408
409
410 /* --------------------------------------------------------------------- */
411
412 /*
413 * `Special' bmap functionality that translates all incomming requests to
414 * translate to vop_strategy() calls with the same blocknumbers effectively
415 * not translating at all.
416 */
417
418 int
419 udf_trivial_bmap(void *v)
420 {
421 struct vop_bmap_args /* {
422 struct vnode *a_vp;
423 daddr_t a_bn;
424 struct vnode **a_vpp;
425 daddr_t *a_bnp;
426 int *a_runp;
427 } */ *ap = v;
428 struct vnode *vp = ap->a_vp; /* our node */
429 struct vnode **vpp = ap->a_vpp; /* return node */
430 daddr_t *bnp = ap->a_bnp; /* translated */
431 daddr_t bn = ap->a_bn; /* origional */
432 int *runp = ap->a_runp;
433 struct udf_node *udf_node = VTOI(vp);
434 uint32_t lb_size;
435
436 /* get logical block size */
437 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
438
439 /* could return `-1' to indicate holes/zeros */
440 /* translate 1:1 */
441 *bnp = bn;
442
443 /* set the vnode to read the data from with strategy on itself */
444 if (vpp)
445 *vpp = vp;
446
447 /* set runlength of maximum block size */
448 if (runp)
449 *runp = MAXPHYS / lb_size; /* or with -1 ? */
450
451 /* return success */
452 return 0;
453 }
454
455 /* --------------------------------------------------------------------- */
456
457 int
458 udf_vfsstrategy(void *v)
459 {
460 struct vop_strategy_args /* {
461 struct vnode *a_vp;
462 struct buf *a_bp;
463 } */ *ap = v;
464 struct vnode *vp = ap->a_vp;
465 struct buf *bp = ap->a_bp;
466 struct udf_node *udf_node = VTOI(vp);
467 uint32_t lb_size, from, sectors;
468 int error;
469
470 DPRINTF(STRATEGY, ("udf_strategy called\n"));
471
472 /* check if we ought to be here */
473 if (vp->v_type == VBLK || vp->v_type == VCHR)
474 panic("udf_strategy: spec");
475
476 /* only filebuffers ought to be read/write by this, no descriptors */
477 assert(bp->b_blkno >= 0);
478
479 /* get sector size */
480 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
481
482 /* calculate sector to start from */
483 from = bp->b_blkno;
484
485 /* calculate length to fetch/store in sectors */
486 sectors = bp->b_bcount / lb_size;
487 assert(bp->b_bcount > 0);
488
489 /* NEVER assume later that this buffer is already translated */
490 /* bp->b_lblkno = bp->b_blkno; */
491
492 /* check assertions: we OUGHT to always get multiples of this */
493 assert(sectors * lb_size == bp->b_bcount);
494
495 /* issue buffer */
496 error = 0;
497 if (bp->b_flags & B_READ) {
498 DPRINTF(STRATEGY, ("\tread vp %p buf %p (blk no %"PRIu64")"
499 ", sector %d for %d sectors\n",
500 vp, bp, bp->b_blkno, from, sectors));
501
502 /* read buffer from the udf_node, translate vtop on the way*/
503 udf_read_filebuf(udf_node, bp);
504 } else {
505 DPRINTF(STRATEGY, ("\twrite vp %p buf %p (blk no %"PRIu64")"
506 ", sector %d for %d sectors\n",
507 vp, bp, bp->b_blkno, from, sectors));
508
509 /* write buffer to the udf_node, translate vtop on the way*/
510 udf_write_filebuf(udf_node, bp);
511 }
512
513 return bp->b_error;
514 }
515
516 /* --------------------------------------------------------------------- */
517
518 int
519 udf_readdir(void *v)
520 {
521 struct vop_readdir_args /* {
522 struct vnode *a_vp;
523 struct uio *a_uio;
524 kauth_cred_t a_cred;
525 int *a_eofflag;
526 off_t **a_cookies;
527 int *a_ncookies;
528 } */ *ap = v;
529 struct uio *uio = ap->a_uio;
530 struct vnode *vp = ap->a_vp;
531 struct udf_node *udf_node = VTOI(vp);
532 struct file_entry *fe;
533 struct extfile_entry *efe;
534 struct fileid_desc *fid;
535 struct dirent *dirent;
536 uint64_t file_size, diroffset, transoffset;
537 uint32_t lb_size;
538 int error;
539
540 DPRINTF(READDIR, ("udf_readdir called\n"));
541
542 /* This operation only makes sense on directory nodes. */
543 if (vp->v_type != VDIR)
544 return ENOTDIR;
545
546 /* get directory filesize */
547 if (udf_node->fe) {
548 fe = udf_node->fe;
549 file_size = udf_rw64(fe->inf_len);
550 } else {
551 assert(udf_node->efe);
552 efe = udf_node->efe;
553 file_size = udf_rw64(efe->inf_len);
554 }
555
556 dirent = malloc(sizeof(struct dirent), M_UDFTEMP, M_WAITOK | M_ZERO);
557
558 /*
559 * Add `.' pseudo entry if at offset zero since its not in the fid
560 * stream
561 */
562 if (uio->uio_offset == 0) {
563 DPRINTF(READDIR, ("\t'.' inserted\n"));
564 strcpy(dirent->d_name, ".");
565 dirent->d_fileno = udf_get_node_id(&udf_node->loc);
566 dirent->d_type = DT_DIR;
567 dirent->d_namlen = strlen(dirent->d_name);
568 dirent->d_reclen = _DIRENT_SIZE(dirent);
569 uiomove(dirent, _DIRENT_SIZE(dirent), uio);
570
571 /* mark with magic value that we have done the dummy */
572 uio->uio_offset = UDF_DIRCOOKIE_DOT;
573 }
574
575 /* we are called just as long as we keep on pushing data in */
576 error = 0;
577 if (uio->uio_offset < file_size) {
578 /* allocate temporary space for fid */
579 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
580 fid = malloc(lb_size, M_UDFTEMP, M_WAITOK);
581
582 if (uio->uio_offset == UDF_DIRCOOKIE_DOT)
583 uio->uio_offset = 0;
584
585 diroffset = uio->uio_offset;
586 transoffset = diroffset;
587 while (diroffset < file_size) {
588 DPRINTF(READDIR, ("\tread in fid stream\n"));
589 /* transfer a new fid/dirent */
590 error = udf_read_fid_stream(vp, &diroffset, fid, dirent);
591 DPRINTFIF(READDIR, error, ("read error in read fid "
592 "stream : %d\n", error));
593 if (error)
594 break;
595
596 /*
597 * If there isn't enough space in the uio to return a
598 * whole dirent, break off read
599 */
600 if (uio->uio_resid < _DIRENT_SIZE(dirent))
601 break;
602
603 /* remember the last entry we transfered */
604 transoffset = diroffset;
605
606 /* skip deleted entries */
607 if (fid->file_char & UDF_FILE_CHAR_DEL)
608 continue;
609
610 /* skip not visible files */
611 if (fid->file_char & UDF_FILE_CHAR_VIS)
612 continue;
613
614 /* copy dirent to the caller */
615 DPRINTF(READDIR, ("\tread dirent `%s', type %d\n",
616 dirent->d_name, dirent->d_type));
617 uiomove(dirent, _DIRENT_SIZE(dirent), uio);
618 }
619
620 /* pass on last transfered offset */
621 uio->uio_offset = transoffset;
622 free(fid, M_UDFTEMP);
623 }
624
625 if (ap->a_eofflag)
626 *ap->a_eofflag = (uio->uio_offset >= file_size);
627
628 #ifdef DEBUG
629 if (udf_verbose & UDF_DEBUG_READDIR) {
630 printf("returning offset %d\n", (uint32_t) uio->uio_offset);
631 if (ap->a_eofflag)
632 printf("returning EOF ? %d\n", *ap->a_eofflag);
633 if (error)
634 printf("readdir returning error %d\n", error);
635 }
636 #endif
637
638 free(dirent, M_UDFTEMP);
639 return error;
640 }
641
642 /* --------------------------------------------------------------------- */
643
644 int
645 udf_lookup(void *v)
646 {
647 struct vop_lookup_args /* {
648 struct vnode *a_dvp;
649 struct vnode **a_vpp;
650 struct componentname *a_cnp;
651 } */ *ap = v;
652 struct vnode *dvp = ap->a_dvp;
653 struct vnode **vpp = ap->a_vpp;
654 struct componentname *cnp = ap->a_cnp;
655 struct udf_node *dir_node, *res_node;
656 struct udf_mount *ump;
657 struct long_ad icb_loc;
658 const char *name;
659 int namelen, nameiop, islastcn, mounted_ro;
660 int vnodetp;
661 int error, found;
662
663 dir_node = VTOI(dvp);
664 ump = dir_node->ump;
665 *vpp = NULL;
666
667 DPRINTF(LOOKUP, ("udf_lookup called\n"));
668
669 /* simplify/clarification flags */
670 nameiop = cnp->cn_nameiop;
671 islastcn = cnp->cn_flags & ISLASTCN;
672 mounted_ro = dvp->v_mount->mnt_flag & MNT_RDONLY;
673
674 /* check exec/dirread permissions first */
675 error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
676 if (error)
677 return error;
678
679 DPRINTF(LOOKUP, ("\taccess ok\n"));
680
681 /*
682 * If requesting a modify on the last path element on a read-only
683 * filingsystem, reject lookup; XXX why is this repeated in every FS ?
684 */
685 if (islastcn && mounted_ro && (nameiop == DELETE || nameiop == RENAME))
686 return EROFS;
687
688 DPRINTF(LOOKUP, ("\tlooking up cnp->cn_nameptr '%s'\n",
689 cnp->cn_nameptr));
690 /* look in the nami cache; returns 0 on success!! */
691 error = cache_lookup(dvp, vpp, cnp);
692 if (error >= 0)
693 return error;
694
695 DPRINTF(LOOKUP, ("\tNOT found in cache\n"));
696
697 /*
698 * Obviously, the file is not (anymore) in the namecache, we have to
699 * search for it. There are three basic cases: '.', '..' and others.
700 *
701 * Following the guidelines of VOP_LOOKUP manpage and tmpfs.
702 */
703 error = 0;
704 if ((cnp->cn_namelen == 1) && (cnp->cn_nameptr[0] == '.')) {
705 DPRINTF(LOOKUP, ("\tlookup '.'\n"));
706 /* special case 1 '.' */
707 vref(dvp);
708 *vpp = dvp;
709 /* done */
710 } else if (cnp->cn_flags & ISDOTDOT) {
711 /* special case 2 '..' */
712 DPRINTF(LOOKUP, ("\tlookup '..'\n"));
713
714 /* get our node */
715 name = "..";
716 namelen = 2;
717 error = udf_lookup_name_in_dir(dvp, name, namelen,
718 &icb_loc, &found);
719 if (error)
720 goto out;
721 if (!found)
722 error = ENOENT;
723
724 /* first unlock parent */
725 VOP_UNLOCK(dvp, 0);
726
727 if (error == 0) {
728 DPRINTF(LOOKUP, ("\tfound '..'\n"));
729 /* try to create/reuse the node */
730 error = udf_get_node(ump, &icb_loc, &res_node);
731
732 if (!error) {
733 DPRINTF(LOOKUP,
734 ("\tnode retrieved/created OK\n"));
735 *vpp = res_node->vnode;
736 }
737 }
738
739 /* try to relock parent */
740 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
741 } else {
742 DPRINTF(LOOKUP, ("\tlookup file\n"));
743 /* all other files */
744 /* lookup filename in the directory; location icb_loc */
745 name = cnp->cn_nameptr;
746 namelen = cnp->cn_namelen;
747 error = udf_lookup_name_in_dir(dvp, name, namelen,
748 &icb_loc, &found);
749 if (error)
750 goto out;
751 if (!found) {
752 DPRINTF(LOOKUP, ("\tNOT found\n"));
753 /*
754 * UGH, didn't find name. If we're creating or
755 * renaming on the last name this is OK and we ought
756 * to return EJUSTRETURN if its allowed to be created.
757 */
758 error = ENOENT;
759 if (islastcn &&
760 (nameiop == CREATE || nameiop == RENAME))
761 error = 0;
762 if (!error) {
763 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
764 if (!error) {
765 /* keep the component name */
766 cnp->cn_flags |= SAVENAME;
767 error = EJUSTRETURN;
768 }
769 }
770 /* done */
771 } else {
772 /* try to create/reuse the node */
773 error = udf_get_node(ump, &icb_loc, &res_node);
774 if (!error) {
775 /*
776 * If we are not at the last path component
777 * and found a non-directory or non-link entry
778 * (which may itself be pointing to a
779 * directory), raise an error.
780 */
781 vnodetp = res_node->vnode->v_type;
782 if ((vnodetp != VDIR) && (vnodetp != VLNK)) {
783 if (!islastcn)
784 error = ENOTDIR;
785 }
786
787 }
788 if (!error) {
789 *vpp = res_node->vnode;
790 }
791 }
792 }
793
794 out:
795 /*
796 * Store result in the cache if requested. If we are creating a file,
797 * the file might not be found and thus putting it into the namecache
798 * might be seen as negative caching.
799 */
800 if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE)
801 cache_enter(dvp, *vpp, cnp);
802
803 DPRINTFIF(LOOKUP, error, ("udf_lookup returing error %d\n", error));
804
805 return error;
806 }
807
808 /* --------------------------------------------------------------------- */
809
810 int
811 udf_getattr(void *v)
812 {
813 struct vop_getattr_args /* {
814 struct vnode *a_vp;
815 struct vattr *a_vap;
816 kauth_cred_t a_cred;
817 struct lwp *a_l;
818 } */ *ap = v;
819 struct vnode *vp = ap->a_vp;
820 struct udf_node *udf_node = VTOI(vp);
821 struct udf_mount *ump = udf_node->ump;
822 struct file_entry *fe = udf_node->fe;
823 struct extfile_entry *efe = udf_node->efe;
824 struct filetimes_extattr_entry *ft_extattr;
825 struct device_extattr_entry *devattr;
826 struct vattr *vap = ap->a_vap;
827 struct timestamp *atime, *mtime, *attrtime, *creatime;
828 uint64_t filesize, blkssize;
829 uint32_t nlink;
830 uint32_t offset, a_l;
831 uint8_t *filedata;
832 uid_t uid;
833 gid_t gid;
834 int error;
835
836 DPRINTF(CALL, ("udf_getattr called\n"));
837
838 /* update times before we returning values */
839 udf_itimes(udf_node, NULL, NULL, NULL);
840
841 /* get descriptor information */
842 if (fe) {
843 nlink = udf_rw16(fe->link_cnt);
844 uid = (uid_t)udf_rw32(fe->uid);
845 gid = (gid_t)udf_rw32(fe->gid);
846 filesize = udf_rw64(fe->inf_len);
847 blkssize = udf_rw64(fe->logblks_rec);
848 atime = &fe->atime;
849 mtime = &fe->mtime;
850 attrtime = &fe->attrtime;
851 filedata = fe->data;
852
853 /* initial guess */
854 creatime = mtime;
855
856 /* check our extended attribute if present */
857 error = udf_extattr_search_intern(udf_node,
858 UDF_FILETIMES_ATTR_NO, "", &offset, &a_l);
859 if (!error) {
860 ft_extattr = (struct filetimes_extattr_entry *)
861 (filedata + offset);
862 if (ft_extattr->existence & UDF_FILETIMES_FILE_CREATION)
863 creatime = &ft_extattr->times[0];
864 }
865 } else {
866 assert(udf_node->efe);
867 nlink = udf_rw16(efe->link_cnt);
868 uid = (uid_t)udf_rw32(efe->uid);
869 gid = (gid_t)udf_rw32(efe->gid);
870 filesize = udf_rw64(efe->inf_len); /* XXX or obj_size? */
871 blkssize = udf_rw64(efe->logblks_rec);
872 atime = &efe->atime;
873 mtime = &efe->mtime;
874 attrtime = &efe->attrtime;
875 creatime = &efe->ctime;
876 filedata = efe->data;
877 }
878
879 /* do the uid/gid translation game */
880 if (uid == (uid_t) -1)
881 uid = ump->mount_args.anon_uid;
882 if (gid == (gid_t) -1)
883 gid = ump->mount_args.anon_gid;
884
885 /* fill in struct vattr with values from the node */
886 vattr_null(vap);
887 vap->va_type = vp->v_type;
888 vap->va_mode = udf_getaccessmode(udf_node);
889 vap->va_nlink = nlink;
890 vap->va_uid = uid;
891 vap->va_gid = gid;
892 vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
893 vap->va_fileid = udf_get_node_id(&udf_node->loc); /* inode hash XXX */
894 vap->va_size = filesize;
895 vap->va_blocksize = udf_node->ump->discinfo.sector_size; /* wise? */
896
897 /*
898 * BUG-ALERT: UDF doesn't count '.' as an entry, so we'll have to add
899 * 1 to the link count if its a directory we're requested attributes
900 * of.
901 */
902 if (vap->va_type == VDIR)
903 vap->va_nlink++;
904
905 /* access times */
906 udf_timestamp_to_timespec(ump, atime, &vap->va_atime);
907 udf_timestamp_to_timespec(ump, mtime, &vap->va_mtime);
908 udf_timestamp_to_timespec(ump, attrtime, &vap->va_ctime);
909 udf_timestamp_to_timespec(ump, creatime, &vap->va_birthtime);
910
911 vap->va_gen = 1; /* no multiple generations yes (!?) */
912 vap->va_flags = 0; /* no flags */
913 vap->va_bytes = blkssize * udf_node->ump->discinfo.sector_size;
914 vap->va_filerev = 1; /* TODO file revision numbers? */
915 vap->va_vaflags = 0;
916 /* TODO get vaflags from the extended attributes? */
917
918 if ((vap->va_type == VBLK) || (vap->va_type == VCHR)) {
919 error = udf_extattr_search_intern(udf_node,
920 UDF_DEVICESPEC_ATTR_NO, "",
921 &offset, &a_l);
922 /* if error, deny access */
923 if (error || (filedata == NULL)) {
924 vap->va_mode = 0; /* or v_type = VNON? */
925 } else {
926 devattr = (struct device_extattr_entry *)
927 filedata + offset;
928 vap->va_rdev = makedev(
929 udf_rw32(devattr->major),
930 udf_rw32(devattr->minor)
931 );
932 /* TODO we could check the implementator */
933 }
934 }
935
936 return 0;
937 }
938
939 /* --------------------------------------------------------------------- */
940
941 static int
942 udf_chown(struct vnode *vp, uid_t new_uid, gid_t new_gid,
943 kauth_cred_t cred)
944 {
945 struct udf_node *udf_node = VTOI(vp);
946 uid_t uid;
947 gid_t gid;
948 int error;
949
950 #ifdef notyet
951 /* TODO get vaflags from the extended attributes? */
952 /* Immutable or append-only files cannot be modified, either. */
953 if (udf_node->flags & (IMMUTABLE | APPEND))
954 return EPERM;
955 #endif
956
957 if (vp->v_mount->mnt_flag & MNT_RDONLY)
958 return EROFS;
959
960 /* retrieve old values */
961 udf_getownership(udf_node, &uid, &gid);
962
963 /* only one could be specified */
964 if (new_uid == VNOVAL)
965 new_uid = uid;
966 if (new_gid == VNOVAL)
967 new_gid = gid;
968
969 /* check if we can fit it in an 32 bits */
970 if ((uid_t) ((uint32_t) new_uid) != new_uid)
971 return EINVAL;
972 if ((gid_t) ((uint32_t) new_gid) != new_gid)
973 return EINVAL;
974
975 /* check permissions */
976 error = genfs_can_chown(vp, cred, uid, gid, new_uid, new_gid);
977 if (error)
978 return (error);
979
980 /* change the ownership */
981 udf_setownership(udf_node, new_uid, new_gid);
982
983 /* mark node changed */
984 udf_node->i_flags |= IN_CHANGE;
985
986 return 0;
987 }
988
989
990 static int
991 udf_chmod(struct vnode *vp, mode_t mode, kauth_cred_t cred)
992 {
993 struct udf_node *udf_node = VTOI(vp);
994 uid_t uid;
995 gid_t gid;
996 int error;
997
998 #ifdef notyet
999 /* TODO get vaflags from the extended attributes? */
1000 /* Immutable or append-only files cannot be modified, either. */
1001 if (udf_node->flags & (IMMUTABLE | APPEND))
1002 return EPERM;
1003 #endif
1004
1005 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1006 return EROFS;
1007
1008 /* retrieve uid/gid values */
1009 udf_getownership(udf_node, &uid, &gid);
1010
1011 /* check permissions */
1012 error = genfs_can_chmod(vp, cred, uid, gid, mode);
1013 if (error)
1014 return (error);
1015
1016 /* change mode */
1017 udf_setaccessmode(udf_node, mode);
1018
1019 /* mark node changed */
1020 udf_node->i_flags |= IN_CHANGE;
1021
1022 return 0;
1023 }
1024
1025
1026 /* exported */
1027 int
1028 udf_chsize(struct vnode *vp, u_quad_t newsize, kauth_cred_t cred)
1029 {
1030 struct udf_node *udf_node = VTOI(vp);
1031 int error, extended;
1032
1033 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1034 return EROFS;
1035
1036 /* Decide whether this is a valid operation based on the file type. */
1037 switch (vp->v_type) {
1038 case VDIR:
1039 return EISDIR;
1040 case VREG:
1041 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1042 return EROFS;
1043 break;
1044 case VBLK:
1045 /* FALLTHROUGH */
1046 case VCHR:
1047 /* FALLTHROUGH */
1048 case VFIFO:
1049 /* Allow modifications of special files even if in the file
1050 * system is mounted read-only (we are not modifying the
1051 * files themselves, but the objects they represent). */
1052 return 0;
1053 default:
1054 /* Anything else is unsupported. */
1055 return EOPNOTSUPP;
1056 }
1057
1058 #if notyet
1059 /* TODO get vaflags from the extended attributes? */
1060 /* Immutable or append-only files cannot be modified, either. */
1061 if (node->flags & (IMMUTABLE | APPEND))
1062 return EPERM;
1063 #endif
1064
1065 /* resize file to the requested size */
1066 error = udf_resize_node(udf_node, newsize, &extended);
1067
1068 if (error == 0) {
1069 /* mark change */
1070 udf_node->i_flags |= IN_CHANGE | IN_MODIFY;
1071 VN_KNOTE(vp, NOTE_ATTRIB | (extended ? NOTE_EXTEND : 0));
1072 udf_update(vp, NULL, NULL, NULL, 0);
1073 }
1074
1075 return error;
1076 }
1077
1078
1079 static int
1080 udf_chflags(struct vnode *vp, mode_t mode, kauth_cred_t cred)
1081 {
1082 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1083 return EROFS;
1084
1085 /* XXX we can't do this yet, but erroring out is enoying XXX */
1086
1087 return 0;
1088 }
1089
1090
1091 static int
1092 udf_chtimes(struct vnode *vp,
1093 struct timespec *atime, struct timespec *mtime,
1094 struct timespec *birthtime, int setattrflags,
1095 kauth_cred_t cred)
1096 {
1097 struct udf_node *udf_node = VTOI(vp);
1098 uid_t uid;
1099 gid_t gid;
1100 int error;
1101
1102 #ifdef notyet
1103 /* TODO get vaflags from the extended attributes? */
1104 /* Immutable or append-only files cannot be modified, either. */
1105 if (udf_node->flags & (IMMUTABLE | APPEND))
1106 return EPERM;
1107 #endif
1108
1109 if (vp->v_mount->mnt_flag & MNT_RDONLY)
1110 return EROFS;
1111
1112 /* retrieve uid/gid values */
1113 udf_getownership(udf_node, &uid, &gid);
1114
1115 /* check permissions */
1116 error = genfs_can_chtimes(vp, setattrflags, uid, cred);
1117 if (error)
1118 return (error);
1119
1120 /* update node flags depending on what times are passed */
1121 if (atime->tv_sec != VNOVAL)
1122 if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
1123 udf_node->i_flags |= IN_ACCESS;
1124 if ((mtime->tv_sec != VNOVAL) || (birthtime->tv_sec != VNOVAL))
1125 udf_node->i_flags |= IN_CHANGE | IN_UPDATE;
1126
1127 return udf_update(vp, atime, mtime, birthtime, 0);
1128 }
1129
1130
1131 int
1132 udf_setattr(void *v)
1133 {
1134 struct vop_setattr_args /* {
1135 struct vnode *a_vp;
1136 struct vattr *a_vap;
1137 kauth_cred_t a_cred;
1138 struct lwp *a_l;
1139 } */ *ap = v;
1140 struct vnode *vp = ap->a_vp;
1141 /* struct udf_node *udf_node = VTOI(vp); */
1142 /* struct udf_mount *ump = udf_node->ump; */
1143 kauth_cred_t cred = ap->a_cred;
1144 struct vattr *vap = ap->a_vap;
1145 int error;
1146
1147 DPRINTF(CALL, ("udf_setattr called\n"));
1148
1149 /* Abort if any unsettable attribute is given. */
1150 error = 0;
1151 if (vap->va_type != VNON ||
1152 vap->va_nlink != VNOVAL ||
1153 vap->va_fsid != VNOVAL ||
1154 vap->va_fileid != VNOVAL ||
1155 vap->va_blocksize != VNOVAL ||
1156 #ifdef notyet
1157 /* checks are debated */
1158 vap->va_ctime.tv_sec != VNOVAL ||
1159 vap->va_ctime.tv_nsec != VNOVAL ||
1160 vap->va_birthtime.tv_sec != VNOVAL ||
1161 vap->va_birthtime.tv_nsec != VNOVAL ||
1162 #endif
1163 vap->va_gen != VNOVAL ||
1164 vap->va_rdev != VNOVAL ||
1165 vap->va_bytes != VNOVAL)
1166 error = EINVAL;
1167
1168 DPRINTF(ATTR, ("setattr changing:\n"));
1169 if (error == 0 && (vap->va_flags != VNOVAL)) {
1170 DPRINTF(ATTR, ("\tchflags\n"));
1171 error = udf_chflags(vp, vap->va_flags, cred);
1172 }
1173
1174 if (error == 0 && (vap->va_size != VNOVAL)) {
1175 DPRINTF(ATTR, ("\tchsize\n"));
1176 error = udf_chsize(vp, vap->va_size, cred);
1177 }
1178
1179 if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL)) {
1180 DPRINTF(ATTR, ("\tchown\n"));
1181 error = udf_chown(vp, vap->va_uid, vap->va_gid, cred);
1182 }
1183
1184 if (error == 0 && (vap->va_mode != VNOVAL)) {
1185 DPRINTF(ATTR, ("\tchmod\n"));
1186 error = udf_chmod(vp, vap->va_mode, cred);
1187 }
1188
1189 if (error == 0 &&
1190 ((vap->va_atime.tv_sec != VNOVAL &&
1191 vap->va_atime.tv_nsec != VNOVAL) ||
1192 (vap->va_mtime.tv_sec != VNOVAL &&
1193 vap->va_mtime.tv_nsec != VNOVAL))
1194 ) {
1195 DPRINTF(ATTR, ("\tchtimes\n"));
1196 error = udf_chtimes(vp, &vap->va_atime, &vap->va_mtime,
1197 &vap->va_birthtime, vap->va_vaflags, cred);
1198 }
1199 VN_KNOTE(vp, NOTE_ATTRIB);
1200
1201 return error;
1202 }
1203
1204 /* --------------------------------------------------------------------- */
1205
1206 /*
1207 * Return POSIX pathconf information for UDF file systems.
1208 */
1209 int
1210 udf_pathconf(void *v)
1211 {
1212 struct vop_pathconf_args /* {
1213 struct vnode *a_vp;
1214 int a_name;
1215 register_t *a_retval;
1216 } */ *ap = v;
1217 uint32_t bits;
1218
1219 DPRINTF(CALL, ("udf_pathconf called\n"));
1220
1221 switch (ap->a_name) {
1222 case _PC_LINK_MAX:
1223 *ap->a_retval = (1<<16)-1; /* 16 bits */
1224 return 0;
1225 case _PC_NAME_MAX:
1226 *ap->a_retval = NAME_MAX;
1227 return 0;
1228 case _PC_PATH_MAX:
1229 *ap->a_retval = PATH_MAX;
1230 return 0;
1231 case _PC_PIPE_BUF:
1232 *ap->a_retval = PIPE_BUF;
1233 return 0;
1234 case _PC_CHOWN_RESTRICTED:
1235 *ap->a_retval = 1;
1236 return 0;
1237 case _PC_NO_TRUNC:
1238 *ap->a_retval = 1;
1239 return 0;
1240 case _PC_SYNC_IO:
1241 *ap->a_retval = 0; /* synchronised is off for performance */
1242 return 0;
1243 case _PC_FILESIZEBITS:
1244 /* 64 bit file offsets -> 2+floor(2log(2^64-1)) = 2 + 63 = 65 */
1245 bits = 64; /* XXX ought to deliver 65 */
1246 #if 0
1247 if (udf_node)
1248 bits = 64 * vp->v_mount->mnt_dev_bshift;
1249 #endif
1250 *ap->a_retval = bits;
1251 return 0;
1252 }
1253
1254 return EINVAL;
1255 }
1256
1257
1258 /* --------------------------------------------------------------------- */
1259
1260 int
1261 udf_open(void *v)
1262 {
1263 struct vop_open_args /* {
1264 struct vnode *a_vp;
1265 int a_mode;
1266 kauth_cred_t a_cred;
1267 struct proc *a_p;
1268 } */ *ap = v;
1269 int flags;
1270
1271 DPRINTF(CALL, ("udf_open called\n"));
1272
1273 /*
1274 * Files marked append-only must be opened for appending.
1275 * TODO: get chflags(2) flags from extened attribute.
1276 */
1277 flags = 0;
1278 if ((flags & APPEND) && (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
1279 return (EPERM);
1280
1281 return 0;
1282 }
1283
1284
1285 /* --------------------------------------------------------------------- */
1286
1287 int
1288 udf_close(void *v)
1289 {
1290 struct vop_close_args /* {
1291 struct vnode *a_vp;
1292 int a_fflag;
1293 kauth_cred_t a_cred;
1294 struct proc *a_p;
1295 } */ *ap = v;
1296 struct vnode *vp = ap->a_vp;
1297 struct udf_node *udf_node = VTOI(vp);
1298 int async = vp->v_mount->mnt_flag & MNT_ASYNC;
1299 int error;
1300
1301 DPRINTF(CALL, ("udf_close called\n"));
1302 udf_node = udf_node; /* shut up gcc */
1303
1304 if (!async && (vp->v_type != VDIR)) {
1305 mutex_enter(&vp->v_interlock);
1306 error = VOP_PUTPAGES(vp, 0, 0, PGO_CLEANIT);
1307 if (error)
1308 return error;
1309 }
1310
1311 mutex_enter(&vp->v_interlock);
1312 if (vp->v_usecount > 1)
1313 udf_itimes(udf_node, NULL, NULL, NULL);
1314 mutex_exit(&vp->v_interlock);
1315
1316 return 0;
1317 }
1318
1319
1320 /* --------------------------------------------------------------------- */
1321
1322 static int
1323 udf_check_possible(struct vnode *vp, struct vattr *vap, mode_t mode)
1324 {
1325 int flags;
1326
1327 /* check if we are allowed to write */
1328 switch (vap->va_type) {
1329 case VDIR:
1330 case VLNK:
1331 case VREG:
1332 /*
1333 * normal nodes: check if we're on a read-only mounted
1334 * filingsystem and bomb out if we're trying to write.
1335 */
1336 if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY))
1337 return EROFS;
1338 break;
1339 case VBLK:
1340 case VCHR:
1341 case VSOCK:
1342 case VFIFO:
1343 /*
1344 * special nodes: even on read-only mounted filingsystems
1345 * these are allowed to be written to if permissions allow.
1346 */
1347 break;
1348 default:
1349 /* no idea what this is */
1350 return EINVAL;
1351 }
1352
1353 /* noone may write immutable files */
1354 /* TODO: get chflags(2) flags from extened attribute. */
1355 flags = 0;
1356 if ((mode & VWRITE) && (flags & IMMUTABLE))
1357 return EPERM;
1358
1359 return 0;
1360 }
1361
1362 static int
1363 udf_check_permitted(struct vnode *vp, struct vattr *vap, mode_t mode,
1364 kauth_cred_t cred)
1365 {
1366
1367 /* ask the generic genfs_can_access to advice on security */
1368 return genfs_can_access(vp->v_type,
1369 vap->va_mode, vap->va_uid, vap->va_gid,
1370 mode, cred);
1371 }
1372
1373 int
1374 udf_access(void *v)
1375 {
1376 struct vop_access_args /* {
1377 struct vnode *a_vp;
1378 int a_mode;
1379 kauth_cred_t a_cred;
1380 struct proc *a_p;
1381 } */ *ap = v;
1382 struct vnode *vp = ap->a_vp;
1383 mode_t mode = ap->a_mode;
1384 kauth_cred_t cred = ap->a_cred;
1385 /* struct udf_node *udf_node = VTOI(vp); */
1386 struct vattr vap;
1387 int error;
1388
1389 DPRINTF(CALL, ("udf_access called\n"));
1390
1391 error = VOP_GETATTR(vp, &vap, NULL);
1392 if (error)
1393 return error;
1394
1395 error = udf_check_possible(vp, &vap, mode);
1396 if (error)
1397 return error;
1398
1399 error = udf_check_permitted(vp, &vap, mode, cred);
1400
1401 return error;
1402 }
1403
1404 /* --------------------------------------------------------------------- */
1405
1406 int
1407 udf_create(void *v)
1408 {
1409 struct vop_create_args /* {
1410 struct vnode *a_dvp;
1411 struct vnode **a_vpp;
1412 struct componentname *a_cnp;
1413 struct vattr *a_vap;
1414 } */ *ap = v;
1415 struct vnode *dvp = ap->a_dvp;
1416 struct vnode **vpp = ap->a_vpp;
1417 struct vattr *vap = ap->a_vap;
1418 struct componentname *cnp = ap->a_cnp;
1419 int error;
1420
1421 DPRINTF(CALL, ("udf_create called\n"));
1422 error = udf_create_node(dvp, vpp, vap, cnp);
1423
1424 if (error || !(cnp->cn_flags & SAVESTART))
1425 PNBUF_PUT(cnp->cn_pnbuf);
1426 vput(dvp);
1427 return error;
1428 }
1429
1430 /* --------------------------------------------------------------------- */
1431
1432 int
1433 udf_mknod(void *v)
1434 {
1435 struct vop_mknod_args /* {
1436 struct vnode *a_dvp;
1437 struct vnode **a_vpp;
1438 struct componentname *a_cnp;
1439 struct vattr *a_vap;
1440 } */ *ap = v;
1441 struct vnode *dvp = ap->a_dvp;
1442 struct vnode **vpp = ap->a_vpp;
1443 struct vattr *vap = ap->a_vap;
1444 struct componentname *cnp = ap->a_cnp;
1445 int error;
1446
1447 DPRINTF(CALL, ("udf_mknod called\n"));
1448 error = udf_create_node(dvp, vpp, vap, cnp);
1449
1450 if (error || !(cnp->cn_flags & SAVESTART))
1451 PNBUF_PUT(cnp->cn_pnbuf);
1452 vput(dvp);
1453 return error;
1454 }
1455
1456 /* --------------------------------------------------------------------- */
1457
1458 int
1459 udf_mkdir(void *v)
1460 {
1461 struct vop_mkdir_args /* {
1462 struct vnode *a_dvp;
1463 struct vnode **a_vpp;
1464 struct componentname *a_cnp;
1465 struct vattr *a_vap;
1466 } */ *ap = v;
1467 struct vnode *dvp = ap->a_dvp;
1468 struct vnode **vpp = ap->a_vpp;
1469 struct vattr *vap = ap->a_vap;
1470 struct componentname *cnp = ap->a_cnp;
1471 int error;
1472
1473 DPRINTF(CALL, ("udf_mkdir called\n"));
1474 error = udf_create_node(dvp, vpp, vap, cnp);
1475
1476 if (error || !(cnp->cn_flags & SAVESTART))
1477 PNBUF_PUT(cnp->cn_pnbuf);
1478 vput(dvp);
1479 return error;
1480 }
1481
1482 /* --------------------------------------------------------------------- */
1483
1484 static int
1485 udf_do_link(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
1486 {
1487 struct udf_node *udf_node, *dir_node;
1488 struct vattr vap;
1489 int error;
1490
1491 DPRINTF(CALL, ("udf_link called\n"));
1492 error = 0;
1493
1494 /* some quick checks */
1495 if (vp->v_type == VDIR)
1496 return EPERM; /* can't link a directory */
1497 if (dvp->v_mount != vp->v_mount)
1498 return EXDEV; /* can't link across devices */
1499 if (dvp == vp)
1500 return EPERM; /* can't be the same */
1501
1502 /* lock node */
1503 error = vn_lock(vp, LK_EXCLUSIVE);
1504 if (error)
1505 return error;
1506
1507 /* get attributes */
1508 dir_node = VTOI(dvp);
1509 udf_node = VTOI(vp);
1510
1511 error = VOP_GETATTR(vp, &vap, FSCRED);
1512 if (error)
1513 return error;
1514
1515 /* check link count overflow */
1516 if (vap.va_nlink >= (1<<16)-1) /* uint16_t */
1517 return EMLINK;
1518
1519 return udf_dir_attach(dir_node->ump, dir_node, udf_node, &vap, cnp);
1520 }
1521
1522 int
1523 udf_link(void *v)
1524 {
1525 struct vop_link_args /* {
1526 struct vnode *a_dvp;
1527 struct vnode *a_vp;
1528 struct componentname *a_cnp;
1529 } */ *ap = v;
1530 struct vnode *dvp = ap->a_dvp;
1531 struct vnode *vp = ap->a_vp;
1532 struct componentname *cnp = ap->a_cnp;
1533 int error;
1534
1535 error = udf_do_link(dvp, vp, cnp);
1536 if (error)
1537 VOP_ABORTOP(dvp, cnp);
1538
1539 if ((vp != dvp) && (VOP_ISLOCKED(vp) == LK_EXCLUSIVE))
1540 VOP_UNLOCK(vp, 0);
1541
1542 VN_KNOTE(vp, NOTE_LINK);
1543 VN_KNOTE(dvp, NOTE_WRITE);
1544 vput(dvp);
1545
1546 return error;
1547 }
1548
1549 /* --------------------------------------------------------------------- */
1550
1551 static int
1552 udf_do_symlink(struct udf_node *udf_node, char *target)
1553 {
1554 struct pathcomp pathcomp;
1555 uint8_t *pathbuf, *pathpos, *compnamepos;
1556 char *mntonname;
1557 int pathlen, len, compnamelen, mntonnamelen;
1558 int error;
1559
1560 /* process `target' to an UDF structure */
1561 pathbuf = malloc(UDF_SYMLINKBUFLEN, M_UDFTEMP, M_WAITOK);
1562 pathpos = pathbuf;
1563 pathlen = 0;
1564
1565 if (*target == '/') {
1566 /* symlink starts from the root */
1567 len = UDF_PATH_COMP_SIZE;
1568 memset(&pathcomp, 0, len);
1569 pathcomp.type = UDF_PATH_COMP_ROOT;
1570
1571 /* check if its mount-point relative! */
1572 mntonname = udf_node->ump->vfs_mountp->mnt_stat.f_mntonname;
1573 mntonnamelen = strlen(mntonname);
1574 if (strlen(target) >= mntonnamelen) {
1575 if (strncmp(target, mntonname, mntonnamelen) == 0) {
1576 pathcomp.type = UDF_PATH_COMP_MOUNTROOT;
1577 target += mntonnamelen;
1578 }
1579 } else {
1580 target++;
1581 }
1582
1583 memcpy(pathpos, &pathcomp, len);
1584 pathpos += len;
1585 pathlen += len;
1586 }
1587
1588 error = 0;
1589 while (*target) {
1590 /* ignore multiple '/' */
1591 while (*target == '/') {
1592 target++;
1593 }
1594 if (!*target)
1595 break;
1596
1597 /* extract component name */
1598 compnamelen = 0;
1599 compnamepos = target;
1600 while ((*target) && (*target != '/')) {
1601 target++;
1602 compnamelen++;
1603 }
1604
1605 /* just trunc if too long ?? (security issue) */
1606 if (compnamelen >= 127) {
1607 error = ENAMETOOLONG;
1608 break;
1609 }
1610
1611 /* convert unix name to UDF name */
1612 len = sizeof(struct pathcomp);
1613 memset(&pathcomp, 0, len);
1614 pathcomp.type = UDF_PATH_COMP_NAME;
1615 len = UDF_PATH_COMP_SIZE;
1616
1617 if ((compnamelen == 2) && (strncmp(compnamepos, "..", 2) == 0))
1618 pathcomp.type = UDF_PATH_COMP_PARENTDIR;
1619 if ((compnamelen == 1) && (*compnamepos == '.'))
1620 pathcomp.type = UDF_PATH_COMP_CURDIR;
1621
1622 if (pathcomp.type == UDF_PATH_COMP_NAME) {
1623 unix_to_udf_name(
1624 (char *) &pathcomp.ident, &pathcomp.l_ci,
1625 compnamepos, compnamelen,
1626 &udf_node->ump->logical_vol->desc_charset);
1627 len = UDF_PATH_COMP_SIZE + pathcomp.l_ci;
1628 }
1629
1630 if (pathlen + len >= UDF_SYMLINKBUFLEN) {
1631 error = ENAMETOOLONG;
1632 break;
1633 }
1634
1635 memcpy(pathpos, &pathcomp, len);
1636 pathpos += len;
1637 pathlen += len;
1638 }
1639
1640 if (error) {
1641 /* aparently too big */
1642 free(pathbuf, M_UDFTEMP);
1643 return error;
1644 }
1645
1646 error = udf_grow_node(udf_node, pathlen);
1647 if (error) {
1648 /* failed to pregrow node */
1649 free(pathbuf, M_UDFTEMP);
1650 return error;
1651 }
1652
1653 /* write out structure on the new file */
1654 error = vn_rdwr(UIO_WRITE, udf_node->vnode,
1655 pathbuf, pathlen, 0,
1656 UIO_SYSSPACE, IO_NODELOCKED | IO_ALTSEMANTICS,
1657 FSCRED, NULL, NULL);
1658
1659 /* return status of symlink contents writeout */
1660 free(pathbuf, M_UDFTEMP);
1661 return error;
1662 }
1663
1664
1665 int
1666 udf_symlink(void *v)
1667 {
1668 struct vop_symlink_args /* {
1669 struct vnode *a_dvp;
1670 struct vnode **a_vpp;
1671 struct componentname *a_cnp;
1672 struct vattr *a_vap;
1673 char *a_target;
1674 } */ *ap = v;
1675 struct vnode *dvp = ap->a_dvp;
1676 struct vnode **vpp = ap->a_vpp;
1677 struct vattr *vap = ap->a_vap;
1678 struct componentname *cnp = ap->a_cnp;
1679 struct udf_node *dir_node;
1680 struct udf_node *udf_node;
1681 int error;
1682
1683 DPRINTF(CALL, ("udf_symlink called\n"));
1684 DPRINTF(CALL, ("\tlinking to `%s`\n", ap->a_target));
1685 error = udf_create_node(dvp, vpp, vap, cnp);
1686 KASSERT(((error == 0) && (*vpp != NULL)) || ((error && (*vpp == NULL))));
1687 if (!error) {
1688 dir_node = VTOI(dvp);
1689 udf_node = VTOI(*vpp);
1690 KASSERT(udf_node);
1691 error = udf_do_symlink(udf_node, ap->a_target);
1692 if (error) {
1693 /* remove node */
1694 udf_shrink_node(udf_node, 0);
1695 udf_dir_detach(udf_node->ump, dir_node, udf_node, cnp);
1696 }
1697 }
1698 if (error || !(cnp->cn_flags & SAVESTART))
1699 PNBUF_PUT(cnp->cn_pnbuf);
1700 vput(dvp);
1701 return error;
1702 }
1703
1704 /* --------------------------------------------------------------------- */
1705
1706 int
1707 udf_readlink(void *v)
1708 {
1709 struct vop_readlink_args /* {
1710 struct vnode *a_vp;
1711 struct uio *a_uio;
1712 kauth_cred_t a_cred;
1713 } */ *ap = v;
1714 struct vnode *vp = ap->a_vp;
1715 struct uio *uio = ap->a_uio;
1716 kauth_cred_t cred = ap->a_cred;
1717 struct udf_node *udf_node;
1718 struct pathcomp pathcomp;
1719 struct vattr vattr;
1720 uint8_t *pathbuf, *targetbuf, *tmpname;
1721 uint8_t *pathpos, *targetpos;
1722 char *mntonname;
1723 int pathlen, targetlen, namelen, mntonnamelen, len, l_ci;
1724 int first, error;
1725
1726 DPRINTF(CALL, ("udf_readlink called\n"));
1727
1728 udf_node = VTOI(vp);
1729 error = VOP_GETATTR(vp, &vattr, cred);
1730 if (error)
1731 return error;
1732
1733 /* claim temporary buffers for translation */
1734 pathbuf = malloc(UDF_SYMLINKBUFLEN, M_UDFTEMP, M_WAITOK);
1735 targetbuf = malloc(PATH_MAX+1, M_UDFTEMP, M_WAITOK);
1736 tmpname = malloc(PATH_MAX+1, M_UDFTEMP, M_WAITOK);
1737 memset(pathbuf, 0, UDF_SYMLINKBUFLEN);
1738 memset(targetbuf, 0, PATH_MAX);
1739
1740 /* read contents of file in our temporary buffer */
1741 error = vn_rdwr(UIO_READ, udf_node->vnode,
1742 pathbuf, vattr.va_size, 0,
1743 UIO_SYSSPACE, IO_NODELOCKED | IO_ALTSEMANTICS,
1744 FSCRED, NULL, NULL);
1745 if (error) {
1746 /* failed to read in symlink contents */
1747 free(pathbuf, M_UDFTEMP);
1748 free(targetbuf, M_UDFTEMP);
1749 free(tmpname, M_UDFTEMP);
1750 return error;
1751 }
1752
1753 /* convert to a unix path */
1754 pathpos = pathbuf;
1755 pathlen = 0;
1756 targetpos = targetbuf;
1757 targetlen = PATH_MAX;
1758 mntonname = udf_node->ump->vfs_mountp->mnt_stat.f_mntonname;
1759 mntonnamelen = strlen(mntonname);
1760
1761 error = 0;
1762 first = 1;
1763 while (vattr.va_size - pathlen >= UDF_PATH_COMP_SIZE) {
1764 len = UDF_PATH_COMP_SIZE;
1765 memcpy(&pathcomp, pathpos, len);
1766 l_ci = pathcomp.l_ci;
1767 switch (pathcomp.type) {
1768 case UDF_PATH_COMP_ROOT :
1769 /* XXX should check for l_ci; bugcompatible now */
1770 if ((targetlen < 1) || !first) {
1771 error = EINVAL;
1772 break;
1773 }
1774 *targetpos++ = '/'; targetlen--;
1775 break;
1776 case UDF_PATH_COMP_MOUNTROOT :
1777 /* XXX what should it be if l_ci > 0 ? [4/48.16.1.2] */
1778 if (l_ci || (targetlen < mntonnamelen+1) || !first) {
1779 error = EINVAL;
1780 break;
1781 }
1782 memcpy(targetpos, mntonname, mntonnamelen);
1783 targetpos += mntonnamelen; targetlen -= mntonnamelen;
1784 if (vattr.va_size-pathlen > UDF_PATH_COMP_SIZE+l_ci) {
1785 /* more follows, so must be directory */
1786 *targetpos++ = '/'; targetlen--;
1787 }
1788 break;
1789 case UDF_PATH_COMP_PARENTDIR :
1790 /* XXX should check for l_ci; bugcompatible now */
1791 if (targetlen < 3) {
1792 error = EINVAL;
1793 break;
1794 }
1795 *targetpos++ = '.'; targetlen--;
1796 *targetpos++ = '.'; targetlen--;
1797 *targetpos++ = '/'; targetlen--;
1798 break;
1799 case UDF_PATH_COMP_CURDIR :
1800 /* XXX should check for l_ci; bugcompatible now */
1801 if (targetlen < 2) {
1802 error = EINVAL;
1803 break;
1804 }
1805 *targetpos++ = '.'; targetlen--;
1806 *targetpos++ = '/'; targetlen--;
1807 break;
1808 case UDF_PATH_COMP_NAME :
1809 if (l_ci == 0) {
1810 error = EINVAL;
1811 break;
1812 }
1813 memset(tmpname, 0, PATH_MAX);
1814 memcpy(&pathcomp, pathpos, len + l_ci);
1815 udf_to_unix_name(tmpname, MAXPATHLEN,
1816 pathcomp.ident, l_ci,
1817 &udf_node->ump->logical_vol->desc_charset);
1818 namelen = strlen(tmpname);
1819 if (targetlen < namelen + 1) {
1820 error = EINVAL;
1821 break;
1822 }
1823 memcpy(targetpos, tmpname, namelen);
1824 targetpos += namelen; targetlen -= namelen;
1825 if (vattr.va_size-pathlen > UDF_PATH_COMP_SIZE+l_ci) {
1826 /* more follows, so must be directory */
1827 *targetpos++ = '/'; targetlen--;
1828 }
1829 break;
1830 default :
1831 error = EINVAL;
1832 break;
1833 }
1834 first = 0;
1835 if (error)
1836 break;
1837 pathpos += UDF_PATH_COMP_SIZE + l_ci;
1838 pathlen += UDF_PATH_COMP_SIZE + l_ci;
1839
1840 }
1841 /* all processed? */
1842 if (vattr.va_size - pathlen > 0)
1843 error = EINVAL;
1844
1845 /* uiomove() to destination */
1846 if (!error)
1847 uiomove(targetbuf, PATH_MAX - targetlen, uio);
1848
1849 free(pathbuf, M_UDFTEMP);
1850 free(targetbuf, M_UDFTEMP);
1851 free(tmpname, M_UDFTEMP);
1852
1853 return error;
1854 }
1855
1856 /* --------------------------------------------------------------------- */
1857
1858 /*
1859 * Check if source directory is in the path of the target directory. Target
1860 * is supplied locked, source is unlocked. The target is always vput before
1861 * returning. Modeled after UFS.
1862 *
1863 * If source is on the path from target to the root, return error.
1864 */
1865
1866 static int
1867 udf_on_rootpath(struct udf_node *source, struct udf_node *target)
1868 {
1869 struct udf_mount *ump = target->ump;
1870 struct udf_node *res_node;
1871 struct long_ad icb_loc, *root_icb;
1872 const char *name;
1873 int namelen;
1874 int error, found;
1875
1876 name = "..";
1877 namelen = 2;
1878 error = 0;
1879 res_node = target;
1880
1881 root_icb = &ump->fileset_desc->rootdir_icb;
1882
1883 /* if nodes are equal, it is no use looking */
1884 if (udf_compare_icb(&source->loc, &target->loc) == 0) {
1885 error = EEXIST;
1886 goto out;
1887 }
1888
1889 /* nothing can exist before the root */
1890 if (udf_compare_icb(root_icb, &target->loc) == 0) {
1891 error = 0;
1892 goto out;
1893 }
1894
1895 for (;;) {
1896 DPRINTF(NODE, ("udf_on_rootpath : "
1897 "source vp %p, looking at vp %p\n",
1898 source->vnode, res_node->vnode));
1899
1900 /* sanity check */
1901 if (res_node->vnode->v_type != VDIR) {
1902 error = ENOTDIR;
1903 goto out;
1904 }
1905
1906 /* go down one level */
1907 error = udf_lookup_name_in_dir(res_node->vnode, name, namelen,
1908 &icb_loc, &found);
1909 DPRINTF(NODE, ("\tlookup of '..' resulted in error %d, "
1910 "found %d\n", error, found));
1911
1912 if (!found)
1913 error = ENOENT;
1914 if (error)
1915 goto out;
1916
1917 /* did we encounter source node? */
1918 if (udf_compare_icb(&icb_loc, &source->loc) == 0) {
1919 error = EINVAL;
1920 goto out;
1921 }
1922
1923 /* did we encounter the root node? */
1924 if (udf_compare_icb(&icb_loc, root_icb) == 0) {
1925 error = 0;
1926 goto out;
1927 }
1928
1929 /* push our intermediate node, we're done with it */
1930 /* DPRINTF(NODE, ("\tvput %p\n", target->vnode)); */
1931 vput(res_node->vnode);
1932
1933 DPRINTF(NODE, ("\tgetting the .. node\n"));
1934 error = udf_get_node(ump, &icb_loc, &res_node);
1935
1936 if (error) { /* argh, bail out */
1937 KASSERT(res_node == NULL);
1938 // res_node = NULL;
1939 goto out;
1940 }
1941 }
1942 out:
1943 DPRINTF(NODE, ("\tresult: %svalid, error = %d\n", error?"in":"", error));
1944
1945 /* put our last node */
1946 if (res_node)
1947 vput(res_node->vnode);
1948
1949 return error;
1950 }
1951
1952 /* note: i tried to follow the logics of the tmpfs rename code */
1953 int
1954 udf_rename(void *v)
1955 {
1956 struct vop_rename_args /* {
1957 struct vnode *a_fdvp;
1958 struct vnode *a_fvp;
1959 struct componentname *a_fcnp;
1960 struct vnode *a_tdvp;
1961 struct vnode *a_tvp;
1962 struct componentname *a_tcnp;
1963 } */ *ap = v;
1964 struct vnode *tvp = ap->a_tvp;
1965 struct vnode *tdvp = ap->a_tdvp;
1966 struct vnode *fvp = ap->a_fvp;
1967 struct vnode *fdvp = ap->a_fdvp;
1968 struct componentname *tcnp = ap->a_tcnp;
1969 struct componentname *fcnp = ap->a_fcnp;
1970 struct udf_node *fnode, *fdnode, *tnode, *tdnode;
1971 struct vattr fvap, tvap;
1972 int error;
1973
1974 DPRINTF(CALL, ("udf_rename called\n"));
1975
1976 /* disallow cross-device renames */
1977 if (fvp->v_mount != tdvp->v_mount ||
1978 (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
1979 error = EXDEV;
1980 goto out_unlocked;
1981 }
1982
1983 fnode = VTOI(fvp);
1984 fdnode = VTOI(fdvp);
1985 tnode = (tvp == NULL) ? NULL : VTOI(tvp);
1986 tdnode = VTOI(tdvp);
1987
1988 /* lock our source dir */
1989 if (fdnode != tdnode) {
1990 error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
1991 if (error != 0)
1992 goto out_unlocked;
1993 }
1994
1995 /* get info about the node to be moved */
1996 error = VOP_GETATTR(fvp, &fvap, FSCRED);
1997 KASSERT(error == 0);
1998
1999 /* check when to delete the old already existing entry */
2000 if (tvp) {
2001 /* get info about the node to be moved to */
2002 error = VOP_GETATTR(fvp, &tvap, FSCRED);
2003 KASSERT(error == 0);
2004
2005 /* if both dirs, make sure the destination is empty */
2006 if (fvp->v_type == VDIR && tvp->v_type == VDIR) {
2007 if (tvap.va_nlink > 2) {
2008 error = ENOTEMPTY;
2009 goto out;
2010 }
2011 }
2012 /* if moving dir, make sure destination is dir too */
2013 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
2014 error = ENOTDIR;
2015 goto out;
2016 }
2017 /* if we're moving a non-directory, make sure dest is no dir */
2018 if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
2019 error = EISDIR;
2020 goto out;
2021 }
2022 }
2023
2024 /* check if moving a directory to a new parent is allowed */
2025 if ((fdnode != tdnode) && (fvp->v_type == VDIR)) {
2026 /* release tvp since we might encounter it and lock up */
2027 if (tvp)
2028 vput(tvp);
2029
2030 /* vref tdvp since we lose its ref in udf_on_rootpath */
2031 vref(tdvp);
2032
2033 /* search if fnode is a component of tdnode's path to root */
2034 error = udf_on_rootpath(fnode, tdnode);
2035
2036 DPRINTF(NODE, ("Dir rename allowed ? %s\n", error ? "NO":"YES"));
2037
2038 if (error) {
2039 /* compensate for our vref earlier */
2040 vrele(tdvp);
2041 goto out;
2042 }
2043
2044 /* relock tdvp; its still here due to the vref earlier */
2045 vn_lock(tdvp, LK_EXCLUSIVE | LK_RETRY);
2046
2047 /*
2048 * re-lookup tvp since the parent has been unlocked, so could
2049 * have changed/removed in the meantime.
2050 */
2051 tcnp->cn_flags &= ~SAVESTART;
2052 error = relookup(tdvp, &tvp, tcnp);
2053 if (error) {
2054 vput(tdvp);
2055 goto out;
2056 }
2057 tnode = (tvp == NULL) ? NULL : VTOI(tvp);
2058 }
2059
2060 /* remove existing entry if present */
2061 if (tvp)
2062 udf_dir_detach(tdnode->ump, tdnode, tnode, tcnp);
2063
2064 /* create new directory entry for the node */
2065 error = udf_dir_attach(tdnode->ump, tdnode, fnode, &fvap, tcnp);
2066 if (error)
2067 goto out;
2068
2069 /* unlink old directory entry for the node, if failing, unattach new */
2070 error = udf_dir_detach(tdnode->ump, fdnode, fnode, fcnp);
2071 if (error)
2072 udf_dir_detach(tdnode->ump, tdnode, fnode, tcnp);
2073 if (error)
2074 goto out;
2075
2076 /* update tnode's '..' if moving directory to new parent */
2077 if ((fdnode != tdnode) && (fvp->v_type == VDIR)) {
2078 /* update fnode's '..' entry */
2079 error = udf_dir_update_rootentry(fnode->ump, fnode, tdnode);
2080 if (error) {
2081 /* 'try' to recover from this situation */
2082 udf_dir_attach(tdnode->ump, fdnode, fnode, &fvap, fcnp);
2083 udf_dir_detach(tdnode->ump, tdnode, fnode, tcnp);
2084 }
2085 }
2086
2087 out:
2088 if (fdnode != tdnode)
2089 VOP_UNLOCK(fdvp, 0);
2090
2091 out_unlocked:
2092 VOP_ABORTOP(tdvp, tcnp);
2093 if (tdvp == tvp)
2094 vrele(tdvp);
2095 else
2096 vput(tdvp);
2097 if (tvp)
2098 vput(tvp);
2099 VOP_ABORTOP(fdvp, fcnp);
2100
2101 /* release source nodes. */
2102 vrele(fdvp);
2103 vrele(fvp);
2104
2105 return error;
2106 }
2107
2108 /* --------------------------------------------------------------------- */
2109
2110 int
2111 udf_remove(void *v)
2112 {
2113 struct vop_remove_args /* {
2114 struct vnode *a_dvp;
2115 struct vnode *a_vp;
2116 struct componentname *a_cnp;
2117 } */ *ap = v;
2118 struct vnode *dvp = ap->a_dvp;
2119 struct vnode *vp = ap->a_vp;
2120 struct componentname *cnp = ap->a_cnp;
2121 struct udf_node *dir_node = VTOI(dvp);
2122 struct udf_node *udf_node = VTOI(vp);
2123 struct udf_mount *ump = dir_node->ump;
2124 int error;
2125
2126 DPRINTF(CALL, ("udf_remove called\n"));
2127 if (vp->v_type != VDIR) {
2128 error = udf_dir_detach(ump, dir_node, udf_node, cnp);
2129 DPRINTFIF(NODE, error, ("\tgot error removing file\n"));
2130 } else {
2131 DPRINTF(NODE, ("\tis a directory: perm. denied\n"));
2132 error = EPERM;
2133 }
2134
2135 if (error == 0) {
2136 VN_KNOTE(vp, NOTE_DELETE);
2137 VN_KNOTE(dvp, NOTE_WRITE);
2138 }
2139
2140 if (dvp == vp)
2141 vrele(vp);
2142 else
2143 vput(vp);
2144 vput(dvp);
2145
2146 return error;
2147 }
2148
2149 /* --------------------------------------------------------------------- */
2150
2151 int
2152 udf_rmdir(void *v)
2153 {
2154 struct vop_rmdir_args /* {
2155 struct vnode *a_dvp;
2156 struct vnode *a_vp;
2157 struct componentname *a_cnp;
2158 } */ *ap = v;
2159 struct vnode *vp = ap->a_vp;
2160 struct vnode *dvp = ap->a_dvp;
2161 struct componentname *cnp = ap->a_cnp;
2162 struct udf_node *dir_node = VTOI(dvp);
2163 struct udf_node *udf_node = VTOI(vp);
2164 struct udf_mount *ump = dir_node->ump;
2165 int refcnt, error;
2166
2167 DPRINTF(NOTIMPL, ("udf_rmdir called\n"));
2168
2169 /* don't allow '.' to be deleted */
2170 if (dir_node == udf_node) {
2171 vrele(dvp);
2172 vput(vp);
2173 return EINVAL;
2174 }
2175
2176 /* check to see if the directory is empty */
2177 error = 0;
2178 if (dir_node->fe) {
2179 refcnt = udf_rw16(udf_node->fe->link_cnt);
2180 } else {
2181 refcnt = udf_rw16(udf_node->efe->link_cnt);
2182 }
2183 if (refcnt > 1) {
2184 /* NOT empty */
2185 vput(dvp);
2186 vput(vp);
2187 return ENOTEMPTY;
2188 }
2189
2190 /* detach the node from the directory */
2191 error = udf_dir_detach(ump, dir_node, udf_node, cnp);
2192 if (error == 0) {
2193 cache_purge(vp);
2194 // cache_purge(dvp); /* XXX from msdosfs, why? */
2195 VN_KNOTE(vp, NOTE_DELETE);
2196 }
2197 DPRINTFIF(NODE, error, ("\tgot error removing file\n"));
2198
2199 /* unput the nodes and exit */
2200 vput(dvp);
2201 vput(vp);
2202
2203 return error;
2204 }
2205
2206 /* --------------------------------------------------------------------- */
2207
2208 int
2209 udf_fsync(void *v)
2210 {
2211 struct vop_fsync_args /* {
2212 struct vnode *a_vp;
2213 kauth_cred_t a_cred;
2214 int a_flags;
2215 off_t offlo;
2216 off_t offhi;
2217 struct proc *a_p;
2218 } */ *ap = v;
2219 struct vnode *vp = ap->a_vp;
2220 struct udf_node *udf_node = VTOI(vp);
2221 int error, flags, wait;
2222
2223 DPRINTF(SYNC, ("udf_fsync called on %p : %s, %s\n",
2224 udf_node,
2225 (ap->a_flags & FSYNC_WAIT) ? "wait":"no wait",
2226 (ap->a_flags & FSYNC_DATAONLY) ? "data_only":"complete"));
2227
2228 /* flush data and wait for it when requested */
2229 wait = (ap->a_flags & FSYNC_WAIT) ? UPDATE_WAIT : 0;
2230 vflushbuf(vp, wait);
2231
2232 if (udf_node == NULL) {
2233 printf("udf_fsync() called on NULL udf_node!\n");
2234 return 0;
2235 }
2236 if (vp->v_tag != VT_UDF) {
2237 printf("udf_fsync() called on node not tagged as UDF node!\n");
2238 return 0;
2239 }
2240
2241 /* set our times */
2242 udf_itimes(udf_node, NULL, NULL, NULL);
2243
2244 /* if called when mounted readonly, never write back */
2245 if (vp->v_mount->mnt_flag & MNT_RDONLY)
2246 return 0;
2247
2248 /* if only data is requested, return */
2249 if (ap->a_flags & FSYNC_DATAONLY)
2250 return 0;
2251
2252 /* check if the node is dirty 'enough'*/
2253 flags = udf_node->i_flags & (IN_MODIFIED | IN_ACCESSED);
2254 if (flags == 0)
2255 return 0;
2256
2257 /* if we don't have to wait, check for IO pending */
2258 if (!wait) {
2259 if (vp->v_numoutput > 0) {
2260 DPRINTF(SYNC, ("udf_fsync %p, rejecting on v_numoutput\n", udf_node));
2261 return 0;
2262 }
2263 if (udf_node->outstanding_bufs > 0) {
2264 DPRINTF(SYNC, ("udf_fsync %p, rejecting on outstanding_bufs\n", udf_node));
2265 return 0;
2266 }
2267 if (udf_node->outstanding_nodedscr > 0) {
2268 DPRINTF(SYNC, ("udf_fsync %p, rejecting on outstanding_nodedscr\n", udf_node));
2269 return 0;
2270 }
2271 }
2272
2273 /* wait until vp->v_numoutput reaches zero i.e. is finished */
2274 if (wait) {
2275 DPRINTF(SYNC, ("udf_fsync %p, waiting\n", udf_node));
2276 mutex_enter(&vp->v_interlock);
2277 while (vp->v_numoutput) {
2278 DPRINTF(SYNC, ("udf_fsync %p, v_numoutput %d\n", udf_node, vp->v_numoutput));
2279 cv_timedwait(&vp->v_cv, &vp->v_interlock, hz/8);
2280 }
2281 mutex_exit(&vp->v_interlock);
2282 DPRINTF(SYNC, ("udf_fsync %p, fin wait\n", udf_node));
2283 }
2284
2285 /* write out node and wait for it if requested */
2286 DPRINTF(SYNC, ("udf_fsync %p, writeout node\n", udf_node));
2287 error = udf_writeout_node(udf_node, wait);
2288 if (error)
2289 return error;
2290
2291 /* TODO/XXX if ap->a_flags & FSYNC_CACHE, we ought to do a disc sync */
2292
2293 return 0;
2294 }
2295
2296 /* --------------------------------------------------------------------- */
2297
2298 int
2299 udf_advlock(void *v)
2300 {
2301 struct vop_advlock_args /* {
2302 struct vnode *a_vp;
2303 void *a_id;
2304 int a_op;
2305 struct flock *a_fl;
2306 int a_flags;
2307 } */ *ap = v;
2308 struct vnode *vp = ap->a_vp;
2309 struct udf_node *udf_node = VTOI(vp);
2310 struct file_entry *fe;
2311 struct extfile_entry *efe;
2312 uint64_t file_size;
2313
2314 DPRINTF(LOCKING, ("udf_advlock called\n"));
2315
2316 /* get directory filesize */
2317 if (udf_node->fe) {
2318 fe = udf_node->fe;
2319 file_size = udf_rw64(fe->inf_len);
2320 } else {
2321 assert(udf_node->efe);
2322 efe = udf_node->efe;
2323 file_size = udf_rw64(efe->inf_len);
2324 }
2325
2326 return lf_advlock(ap, &udf_node->lockf, file_size);
2327 }
2328
2329 /* --------------------------------------------------------------------- */
2330
2331 /* Global vfs vnode data structures for udfs */
2332 int (**udf_vnodeop_p)(void *);
2333
2334 const struct vnodeopv_entry_desc udf_vnodeop_entries[] = {
2335 { &vop_default_desc, vn_default_error },
2336 { &vop_lookup_desc, udf_lookup }, /* lookup */
2337 { &vop_create_desc, udf_create }, /* create */
2338 { &vop_mknod_desc, udf_mknod }, /* mknod */ /* TODO */
2339 { &vop_open_desc, udf_open }, /* open */
2340 { &vop_close_desc, udf_close }, /* close */
2341 { &vop_access_desc, udf_access }, /* access */
2342 { &vop_getattr_desc, udf_getattr }, /* getattr */
2343 { &vop_setattr_desc, udf_setattr }, /* setattr */ /* TODO chflags */
2344 { &vop_read_desc, udf_read }, /* read */
2345 { &vop_write_desc, udf_write }, /* write */ /* WRITE */
2346 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ /* TODO? */
2347 { &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */ /* TODO? */
2348 { &vop_poll_desc, genfs_poll }, /* poll */ /* TODO/OK? */
2349 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */ /* ? */
2350 { &vop_revoke_desc, genfs_revoke }, /* revoke */ /* TODO? */
2351 { &vop_mmap_desc, genfs_mmap }, /* mmap */ /* OK? */
2352 { &vop_fsync_desc, udf_fsync }, /* fsync */
2353 { &vop_seek_desc, genfs_seek }, /* seek */
2354 { &vop_remove_desc, udf_remove }, /* remove */
2355 { &vop_link_desc, udf_link }, /* link */ /* TODO */
2356 { &vop_rename_desc, udf_rename }, /* rename */ /* TODO */
2357 { &vop_mkdir_desc, udf_mkdir }, /* mkdir */
2358 { &vop_rmdir_desc, udf_rmdir }, /* rmdir */
2359 { &vop_symlink_desc, udf_symlink }, /* symlink */ /* TODO */
2360 { &vop_readdir_desc, udf_readdir }, /* readdir */
2361 { &vop_readlink_desc, udf_readlink }, /* readlink */ /* TEST ME */
2362 { &vop_abortop_desc, genfs_abortop }, /* abortop */ /* TODO/OK? */
2363 { &vop_inactive_desc, udf_inactive }, /* inactive */
2364 { &vop_reclaim_desc, udf_reclaim }, /* reclaim */
2365 { &vop_lock_desc, genfs_lock }, /* lock */
2366 { &vop_unlock_desc, genfs_unlock }, /* unlock */
2367 { &vop_bmap_desc, udf_trivial_bmap }, /* bmap */ /* 1:1 bmap */
2368 { &vop_strategy_desc, udf_vfsstrategy },/* strategy */
2369 /* { &vop_print_desc, udf_print }, */ /* print */
2370 { &vop_islocked_desc, genfs_islocked }, /* islocked */
2371 { &vop_pathconf_desc, udf_pathconf }, /* pathconf */
2372 { &vop_advlock_desc, udf_advlock }, /* advlock */ /* TEST ME */
2373 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ /* ->strategy */
2374 { &vop_getpages_desc, genfs_getpages }, /* getpages */
2375 { &vop_putpages_desc, genfs_putpages }, /* putpages */
2376 { NULL, NULL }
2377 };
2378
2379
2380 const struct vnodeopv_desc udf_vnodeop_opv_desc = {
2381 &udf_vnodeop_p, udf_vnodeop_entries
2382 };
2383
NetBSD on the FriendlyARM MINI2440