xref: /openbsd-src/sys/kern/vfs_vops.c (revision 99fd087599a8791921855f21bd7e36130f39aadc)
1 /*	$OpenBSD: vfs_vops.c,v 1.25 2020/02/14 11:57:56 claudio Exp $	*/
2 /*
3  * Copyright (c) 2010 Thordur I. Bjornsson <thib@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  *
17  * Copyright (c) 1992, 1993
18  *	The Regents of the University of California.  All rights reserved.
19  *
20  * Redistribution and use in source and binary forms, with or without
21  * modification, are permitted provided that the following conditions
22  * are met:
23  * 1. Redistributions of source code must retain the above copyright
24  *    notice, this list of conditions and the following disclaimer.
25  * 2. Redistributions in binary form must reproduce the above copyright
26  *    notice, this list of conditions and the following disclaimer in the
27  *    documentation and/or other materials provided with the distribution.
28  * 3. Neither the name of the University nor the names of its contributors
29  *    may be used to endorse or promote products derived from this software
30  *    without specific prior written permission.
31  *
32  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42  * SUCH DAMAGE.
43  */
44 
45 #include <sys/param.h>
46 #include <sys/vnode.h>
47 #include <sys/unistd.h>
48 #include <sys/systm.h>
49 
50 #ifdef VFSLCKDEBUG
51 #include <sys/systm.h>		/* for panic() */
52 
53 #define ASSERT_VP_ISLOCKED(vp) do {				\
54 	if (((vp)->v_flag & VLOCKSWORK) && !VOP_ISLOCKED(vp)) {	\
55 		VOP_PRINT(vp);					\
56 		panic("vp not locked");				\
57 	}							\
58 } while (0)
59 #else
60 #define ASSERT_VP_ISLOCKED(vp)  /* nothing */
61 #endif
62 
63 int
64 VOP_ISLOCKED(struct vnode *vp)
65 {
66 	struct vop_islocked_args a;
67 	a.a_vp = vp;
68 
69 	if (vp->v_op->vop_islocked == NULL)
70 		return (EOPNOTSUPP);
71 
72 	return ((vp->v_op->vop_islocked)(&a));
73 }
74 
75 int
76 VOP_LOOKUP(struct vnode *dvp, struct vnode **vpp,
77     struct componentname *cnp)
78 {
79 	int r;
80 	struct vop_lookup_args a;
81 	a.a_dvp = dvp;
82 	a.a_vpp = vpp;
83 	a.a_cnp = cnp;
84 
85 	if (dvp->v_op->vop_lookup == NULL)
86 		return (EOPNOTSUPP);
87 
88 	dvp->v_inflight++;
89 	r = (dvp->v_op->vop_lookup)(&a);
90 	dvp->v_inflight--;
91 	return r;
92 }
93 
94 int
95 VOP_CREATE(struct vnode *dvp, struct vnode **vpp,
96     struct componentname *cnp, struct vattr *vap)
97 {
98 	int r;
99 	struct vop_create_args a;
100 	a.a_dvp = dvp;
101 	a.a_vpp = vpp;
102 	a.a_cnp = cnp;
103 	a.a_vap = vap;
104 
105 	ASSERT_VP_ISLOCKED(dvp);
106 
107 	if (dvp->v_op->vop_create == NULL)
108 		return (EOPNOTSUPP);
109 
110 	dvp->v_inflight++;
111 	r = (dvp->v_op->vop_create)(&a);
112 	dvp->v_inflight--;
113 	return r;
114 }
115 
116 int
117 VOP_MKNOD(struct vnode *dvp, struct vnode **vpp,
118     struct componentname *cnp, struct vattr *vap)
119 {
120 	int r;
121 	struct vop_mknod_args a;
122 	a.a_dvp = dvp;
123 	a.a_vpp = vpp;
124 	a.a_cnp = cnp;
125 	a.a_vap = vap;
126 
127 	ASSERT_VP_ISLOCKED(dvp);
128 
129 	if (dvp->v_op->vop_mknod == NULL)
130 		return (EOPNOTSUPP);
131 
132 	dvp->v_inflight++;
133 	r = (dvp->v_op->vop_mknod)(&a);
134 	dvp->v_inflight--;
135 	return r;
136 }
137 
138 int
139 VOP_OPEN(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
140 {
141 	int r;
142 	struct vop_open_args a;
143 	a.a_vp = vp;
144 	a.a_mode = mode;
145 	a.a_cred = cred;
146 	a.a_p = p;
147 
148 	if (vp->v_op->vop_open == NULL)
149 		return (EOPNOTSUPP);
150 
151 	vp->v_inflight++;
152 	r = (vp->v_op->vop_open)(&a);
153 	vp->v_inflight--;
154 	return r;
155 }
156 
157 int
158 VOP_CLOSE(struct vnode *vp, int fflag, struct ucred *cred, struct proc *p)
159 {
160 	int r;
161 	struct vop_close_args a;
162 	a.a_vp = vp;
163 	a.a_fflag = fflag;
164 	a.a_cred = cred;
165 	a.a_p = p;
166 
167 	ASSERT_VP_ISLOCKED(vp);
168 
169 	if (vp->v_op->vop_close == NULL)
170 		return (EOPNOTSUPP);
171 
172 	vp->v_inflight++;
173 	r = (vp->v_op->vop_close)(&a);
174 	vp->v_inflight--;
175 	return r;
176 }
177 
178 int
179 VOP_ACCESS(struct vnode *vp, int mode, struct ucred *cred, struct proc *p)
180 {
181 	struct vop_access_args a;
182 	a.a_vp = vp;
183 	a.a_mode = mode;
184 	a.a_cred = cred;
185 	a.a_p = p;
186 
187 	ASSERT_VP_ISLOCKED(vp);
188 
189 	if (vp->v_op->vop_access == NULL)
190 		return (EOPNOTSUPP);
191 
192 	return ((vp->v_op->vop_access)(&a));
193 }
194 
195 int
196 VOP_GETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
197     struct proc *p)
198 {
199 	struct vop_getattr_args a;
200 	a.a_vp = vp;
201 	a.a_vap = vap;
202 	a.a_cred = cred;
203 	a.a_p = p;
204 
205 	if (vp->v_op->vop_getattr == NULL)
206 		return (EOPNOTSUPP);
207 
208 	return ((vp->v_op->vop_getattr)(&a));
209 }
210 
211 int
212 VOP_SETATTR(struct vnode *vp, struct vattr *vap, struct ucred *cred,
213     struct proc *p)
214 {
215 	int r;
216 	struct vop_setattr_args a;
217 	a.a_vp = vp;
218 	a.a_vap = vap;
219 	a.a_cred = cred;
220 	a.a_p = p;
221 
222 	ASSERT_VP_ISLOCKED(vp);
223 
224 	if (vp->v_op->vop_setattr == NULL)
225 		return (EOPNOTSUPP);
226 
227 	vp->v_inflight++;
228 	r = (vp->v_op->vop_setattr)(&a);
229 	vp->v_inflight--;
230 	return r;
231 }
232 
233 int
234 VOP_READ(struct vnode *vp, struct uio *uio, int ioflag, struct ucred *cred)
235 {
236 	struct vop_read_args a;
237 	a.a_vp = vp;
238 	a.a_uio = uio;
239 	a.a_ioflag = ioflag;
240 	a.a_cred = cred;
241 
242 	ASSERT_VP_ISLOCKED(vp);
243 
244 	if (vp->v_op->vop_read == NULL)
245 		return (EOPNOTSUPP);
246 
247 	return ((vp->v_op->vop_read)(&a));
248 }
249 
250 int
251 VOP_WRITE(struct vnode *vp, struct uio *uio, int ioflag,
252     struct ucred *cred)
253 {
254 	int r;
255 	struct vop_write_args a;
256 	a.a_vp = vp;
257 	a.a_uio = uio;
258 	a.a_ioflag = ioflag;
259 	a.a_cred = cred;
260 
261 	ASSERT_VP_ISLOCKED(vp);
262 
263 	if (vp->v_op->vop_write == NULL)
264 		return (EOPNOTSUPP);
265 
266 	vp->v_inflight++;
267 	r = (vp->v_op->vop_write)(&a);
268 	vp->v_inflight--;
269 	return r;
270 }
271 
272 int
273 VOP_IOCTL(struct vnode *vp, u_long command, void *data, int fflag,
274     struct ucred *cred, struct proc *p)
275 {
276 	int r;
277 	struct vop_ioctl_args a;
278 	a.a_vp = vp;
279 	a.a_command = command;
280 	a.a_data = data;
281 	a.a_fflag = fflag;
282 	a.a_cred = cred;
283 	a.a_p = p;
284 
285 	if (vp->v_op->vop_ioctl == NULL)
286 		return (EOPNOTSUPP);
287 
288 	vp->v_inflight++;
289 	r = (vp->v_op->vop_ioctl)(&a);
290 	vp->v_inflight--;
291 	return r;
292 }
293 
294 int
295 VOP_POLL(struct vnode *vp, int fflag, int events, struct proc *p)
296 {
297 	struct vop_poll_args a;
298 	a.a_vp = vp;
299 	a.a_fflag = fflag;
300 	a.a_events = events;
301 	a.a_p = p;
302 
303 	if (vp->v_op->vop_poll == NULL)
304 		return (EOPNOTSUPP);
305 
306 	return ((vp->v_op->vop_poll)(&a));
307 }
308 
309 int
310 VOP_KQFILTER(struct vnode *vp, struct knote *kn)
311 {
312 	struct vop_kqfilter_args a;
313 	a.a_vp = vp;
314 	a.a_kn = kn;
315 
316 	if (vp->v_op->vop_kqfilter == NULL)
317 		return (EOPNOTSUPP);
318 
319 	return ((vp->v_op->vop_kqfilter)(&a));
320 }
321 
322 int
323 VOP_REVOKE(struct vnode *vp, int flags)
324 {
325 	struct vop_revoke_args a;
326 	a.a_vp = vp;
327 	a.a_flags = flags;
328 
329 	if (vp->v_op->vop_revoke == NULL)
330 		return (EOPNOTSUPP);
331 
332 	return ((vp->v_op->vop_revoke)(&a));
333 }
334 
335 int
336 VOP_FSYNC(struct vnode *vp, struct ucred *cred, int waitfor,
337     struct proc *p)
338 {
339 	int r, s;
340 	struct vop_fsync_args a;
341 	a.a_vp = vp;
342 	a.a_cred = cred;
343 	a.a_waitfor = waitfor;
344 	a.a_p = p;
345 
346 	ASSERT_VP_ISLOCKED(vp);
347 
348 	if (vp->v_op->vop_fsync == NULL)
349 		return (EOPNOTSUPP);
350 
351 	vp->v_inflight++;
352 	r = (vp->v_op->vop_fsync)(&a);
353 	vp->v_inflight--;
354 	s = splbio();
355 	if (r == 0 && vp->v_bioflag & VBIOERROR)
356 		r = EIO;
357 	splx(s);
358 	return r;
359 }
360 
361 int
362 VOP_REMOVE(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
363 {
364 	int r;
365 	struct vop_remove_args a;
366 	a.a_dvp = dvp;
367         a.a_vp = vp;
368 	a.a_cnp = cnp;
369 
370 	ASSERT_VP_ISLOCKED(dvp);
371 	ASSERT_VP_ISLOCKED(vp);
372 
373 	if (dvp->v_op->vop_remove == NULL)
374 		return (EOPNOTSUPP);
375 
376 	dvp->v_inflight++;
377 	r = (dvp->v_op->vop_remove)(&a);
378 	dvp->v_inflight--;
379 	return r;
380 }
381 
382 int
383 VOP_LINK(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
384 {
385 	int r;
386 	struct vop_link_args a;
387 	a.a_dvp = dvp;
388 	a.a_vp = vp;
389 	a.a_cnp = cnp;
390 
391 	ASSERT_VP_ISLOCKED(dvp);
392 
393 	if (dvp->v_op->vop_link == NULL)
394 		return (EOPNOTSUPP);
395 
396 	dvp->v_inflight++;
397 	vp->v_inflight++;
398 	r = (dvp->v_op->vop_link)(&a);
399 	dvp->v_inflight--;
400 	vp->v_inflight--;
401 	return r;
402 }
403 
404 int
405 VOP_RENAME(struct vnode *fdvp, struct vnode *fvp,
406     struct componentname *fcnp, struct vnode *tdvp, struct vnode *tvp,
407     struct componentname *tcnp)
408 {
409 	int r;
410 	struct vop_rename_args a;
411 	a.a_fdvp = fdvp;
412 	a.a_fvp = fvp;
413 	a.a_fcnp = fcnp;
414 	a.a_tdvp = tdvp;
415 	a.a_tvp = tvp;
416 	a.a_tcnp = tcnp;
417 
418 	ASSERT_VP_ISLOCKED(tdvp);
419 
420 	if (fdvp->v_op->vop_rename == NULL)
421 		return (EOPNOTSUPP);
422 
423 	fdvp->v_inflight++;
424 	tdvp->v_inflight++;
425 	r = (fdvp->v_op->vop_rename)(&a);
426 	fdvp->v_inflight--;
427 	tdvp->v_inflight--;
428 	return r;
429 }
430 
431 int
432 VOP_MKDIR(struct vnode *dvp, struct vnode **vpp,
433     struct componentname *cnp, struct vattr *vap)
434 {
435 	int r;
436 	struct vop_mkdir_args a;
437 	a.a_dvp = dvp;
438 	a.a_vpp = vpp;
439 	a.a_cnp = cnp;
440 	a.a_vap = vap;
441 
442 	ASSERT_VP_ISLOCKED(dvp);
443 
444 	if (dvp->v_op->vop_mkdir == NULL)
445 		return (EOPNOTSUPP);
446 
447 	dvp->v_inflight++;
448 	r = (dvp->v_op->vop_mkdir)(&a);
449 	dvp->v_inflight--;
450 	return r;
451 }
452 
453 int
454 VOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
455 {
456 	int r;
457 	struct vop_rmdir_args a;
458 	a.a_dvp = dvp;
459 	a.a_vp = vp;
460 	a.a_cnp = cnp;
461 
462 	ASSERT_VP_ISLOCKED(dvp);
463 	ASSERT_VP_ISLOCKED(vp);
464 
465 	KASSERT(dvp != vp);
466 
467 	if (dvp->v_op->vop_rmdir == NULL)
468 		return (EOPNOTSUPP);
469 
470 	dvp->v_inflight++;
471 	vp->v_inflight++;
472 	r = (dvp->v_op->vop_rmdir)(&a);
473 	dvp->v_inflight--;
474 	vp->v_inflight--;
475 	return r;
476 }
477 
478 int
479 VOP_SYMLINK(struct vnode *dvp, struct vnode **vpp,
480     struct componentname *cnp, struct vattr *vap, char *target)
481 {
482 	int r;
483 	struct vop_symlink_args a;
484 	a.a_dvp = dvp;
485 	a.a_vpp = vpp;
486 	a.a_cnp = cnp;
487 	a.a_vap = vap;
488 	a.a_target = target;
489 
490 	ASSERT_VP_ISLOCKED(dvp);
491 
492 	if (dvp->v_op->vop_symlink == NULL)
493 		return (EOPNOTSUPP);
494 
495 	dvp->v_inflight++;
496 	r = (dvp->v_op->vop_symlink)(&a);
497 	dvp->v_inflight--;
498 	return r;
499 }
500 
501 int
502 VOP_READDIR(struct vnode *vp, struct uio *uio, struct ucred *cred,
503     int *eofflag)
504 {
505 	int r;
506 	struct vop_readdir_args a;
507 	a.a_vp = vp;
508 	a.a_uio = uio;
509 	a.a_cred = cred;
510 	a.a_eofflag = eofflag;
511 
512 	ASSERT_VP_ISLOCKED(vp);
513 
514 	if (vp->v_op->vop_readdir == NULL)
515 		return (EOPNOTSUPP);
516 
517 	vp->v_inflight++;
518 	r = (vp->v_op->vop_readdir)(&a);
519 	vp->v_inflight--;
520 	return r;
521 }
522 
523 int
524 VOP_READLINK(struct vnode *vp, struct uio *uio, struct ucred *cred)
525 {
526 	int r;
527 	struct vop_readlink_args a;
528 	a.a_vp = vp;
529 	a.a_uio = uio;
530 	a.a_cred = cred;
531 
532 	ASSERT_VP_ISLOCKED(vp);
533 
534 	if (vp->v_op->vop_readlink == NULL)
535 		return (EOPNOTSUPP);
536 
537 	vp->v_inflight++;
538 	r = (vp->v_op->vop_readlink)(&a);
539 	vp->v_inflight--;
540 	return r;
541 }
542 
543 int
544 VOP_ABORTOP(struct vnode *dvp, struct componentname *cnp)
545 {
546 	int r;
547 	struct vop_abortop_args a;
548 	a.a_dvp = dvp;
549 	a.a_cnp = cnp;
550 
551 	if (dvp->v_op->vop_abortop == NULL)
552 		return (EOPNOTSUPP);
553 
554 	dvp->v_inflight++;
555 	r = (dvp->v_op->vop_abortop)(&a);
556 	dvp->v_inflight--;
557 	return r;
558 }
559 
560 int
561 VOP_INACTIVE(struct vnode *vp, struct proc *p)
562 {
563 	struct vop_inactive_args a;
564 	a.a_vp = vp;
565 	a.a_p = p;
566 
567 	ASSERT_VP_ISLOCKED(vp);
568 
569 	if (vp->v_op->vop_inactive == NULL)
570 		return (EOPNOTSUPP);
571 
572 	return ((vp->v_op->vop_inactive)(&a));
573 }
574 
575 int
576 VOP_RECLAIM(struct vnode *vp, struct proc *p)
577 {
578 	int r;
579 	struct vop_reclaim_args a;
580 	a.a_vp = vp;
581 	a.a_p = p;
582 
583 	if (vp->v_op->vop_reclaim == NULL)
584 		return (EOPNOTSUPP);
585 
586 	vp->v_inflight++;
587 	r = (vp->v_op->vop_reclaim)(&a);
588 	vp->v_inflight--;
589 	return r;
590 }
591 
592 int
593 VOP_LOCK(struct vnode *vp, int flags)
594 {
595 	struct vop_lock_args a;
596 	a.a_vp = vp;
597 	a.a_flags = flags;
598 
599 	if (vp->v_op->vop_lock == NULL)
600 		return (EOPNOTSUPP);
601 
602 	return ((vp->v_op->vop_lock)(&a));
603 }
604 
605 int
606 VOP_UNLOCK(struct vnode *vp)
607 {
608 	struct vop_unlock_args a;
609 	a.a_vp = vp;
610 
611 	if (vp->v_op->vop_unlock == NULL)
612 		return (EOPNOTSUPP);
613 
614 	return ((vp->v_op->vop_unlock)(&a));
615 }
616 
617 int
618 VOP_BMAP(struct vnode *vp, daddr_t bn, struct vnode **vpp,
619     daddr_t *bnp, int *runp)
620 {
621 	struct vop_bmap_args a;
622 	a.a_vp = vp;
623 	a.a_bn = bn;
624 	a.a_vpp = vpp;
625 	a.a_bnp = bnp;
626 	a.a_runp = runp;
627 
628 	ASSERT_VP_ISLOCKED(vp);
629 
630 	if (vp->v_op->vop_bmap == NULL)
631 		return (EOPNOTSUPP);
632 
633 	return ((vp->v_op->vop_bmap)(&a));
634 }
635 
636 int
637 VOP_PRINT(struct vnode *vp)
638 {
639 	struct vop_print_args a;
640 	a.a_vp = vp;
641 
642 	if (vp->v_op->vop_print == NULL)
643 		return (EOPNOTSUPP);
644 
645 	return ((vp->v_op->vop_print)(&a));
646 }
647 
648 int
649 VOP_PATHCONF(struct vnode *vp, int name, register_t *retval)
650 {
651 	struct vop_pathconf_args a;
652 
653 	/*
654 	 * Handle names that are constant across filesystem
655 	 */
656 	switch (name) {
657 	case _PC_PATH_MAX:
658 		*retval = PATH_MAX;
659 		return (0);
660 	case _PC_PIPE_BUF:
661 		*retval = PIPE_BUF;
662 		return (0);
663 	case _PC_ASYNC_IO:
664 	case _PC_PRIO_IO:
665 	case _PC_SYNC_IO:
666 		*retval = 0;
667 		return (0);
668 
669 	}
670 
671 	a.a_vp = vp;
672 	a.a_name = name;
673 	a.a_retval = retval;
674 
675 	ASSERT_VP_ISLOCKED(vp);
676 
677 	if (vp->v_op->vop_pathconf == NULL)
678 		return (EOPNOTSUPP);
679 
680 	return ((vp->v_op->vop_pathconf)(&a));
681 }
682 
683 int
684 VOP_ADVLOCK(struct vnode *vp, void *id, int op, struct flock *fl, int flags)
685 {
686 	struct vop_advlock_args a;
687 	a.a_vp = vp;
688 	a.a_id = id;
689 	a.a_op = op;
690 	a.a_fl = fl;
691 	a.a_flags = flags;
692 
693 	if (vp->v_op->vop_advlock == NULL)
694 		return (EOPNOTSUPP);
695 
696 	return (vp->v_op->vop_advlock)(&a);
697 }
698 
699 int
700 VOP_STRATEGY(struct buf *bp)
701 {
702 	struct vop_strategy_args a;
703 	a.a_bp = bp;
704 
705 	if ((ISSET(bp->b_flags, B_BC)) && (!ISSET(bp->b_flags, B_DMA)))
706 		panic("Non dma reachable buffer passed to VOP_STRATEGY");
707 
708 	if (bp->b_vp->v_op->vop_strategy == NULL)
709 		return (EOPNOTSUPP);
710 
711 	return ((bp->b_vp->v_op->vop_strategy)(&a));
712 }
713 
714 int
715 VOP_BWRITE(struct buf *bp)
716 {
717 	struct vop_bwrite_args a;
718 	a.a_bp = bp;
719 
720 	if (bp->b_vp->v_op->vop_bwrite == NULL)
721 		return (EOPNOTSUPP);
722 
723 	return ((bp->b_vp->v_op->vop_bwrite)(&a));
724 }
725