![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_inode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / ufs|
Return to ufs_inode.c CVS log | Up to [Net/2] / Net2 / ufs |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * 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: * @(#)ufs_inode.c 7.40 (Berkeley) 5/8/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "mount.h"
39: #include "proc.h"
40: #include "file.h"
41: #include "buf.h"
42: #include "vnode.h"
43: #include "kernel.h"
44: #include "malloc.h"
45:
46: #include "quota.h"
47: #include "inode.h"
48: #include "fs.h"
49: #include "ufsmount.h"
50:
51: #define INOHSZ 512
52: #if ((INOHSZ&(INOHSZ-1)) == 0)
53: #define INOHASH(dev,ino) (((dev)+(ino))&(INOHSZ-1))
54: #else
55: #define INOHASH(dev,ino) (((unsigned)((dev)+(ino)))%INOHSZ)
56: #endif
57:
58: union ihead {
59: union ihead *ih_head[2];
60: struct inode *ih_chain[2];
61: } ihead[INOHSZ];
62:
63: int prtactive; /* 1 => print out reclaim of active vnodes */
64:
65: /*
66: * Initialize hash links for inodes.
67: */
68: ufs_init()
69: {
70: register int i;
71: register union ihead *ih = ihead;
72:
73: #ifndef lint
74: if (VN_MAXPRIVATE < sizeof(struct inode))
75: panic("ihinit: too small");
76: #endif /* not lint */
77: for (i = INOHSZ; --i >= 0; ih++) {
78: ih->ih_head[0] = ih;
79: ih->ih_head[1] = ih;
80: }
81: #ifdef QUOTA
82: dqinit();
83: #endif /* QUOTA */
84: }
85:
86: /*
87: * Look up a UFS dinode number to find its incore vnode.
88: * If it is not in core, read it in from the specified device.
89: * If it is in core, wait for the lock bit to clear, then
90: * return the inode locked. Detection and handling of mount
91: * points must be done by the calling routine.
92: */
93: iget(xp, ino, ipp)
94: struct inode *xp;
95: ino_t ino;
96: struct inode **ipp;
97: {
98: dev_t dev = xp->i_dev;
99: struct mount *mntp = ITOV(xp)->v_mount;
100: register struct fs *fs = VFSTOUFS(mntp)->um_fs;
101: extern struct vnodeops ufs_vnodeops, spec_inodeops;
102: register struct inode *ip, *iq;
103: register struct vnode *vp;
104: struct vnode *nvp;
105: struct buf *bp;
106: struct dinode *dp;
107: union ihead *ih;
108: int i, error;
109:
110: ih = &ihead[INOHASH(dev, ino)];
111: loop:
112: for (ip = ih->ih_chain[0]; ip != (struct inode *)ih; ip = ip->i_forw) {
113: if (ino != ip->i_number || dev != ip->i_dev)
114: continue;
115: if ((ip->i_flag&ILOCKED) != 0) {
116: ip->i_flag |= IWANT;
117: sleep((caddr_t)ip, PINOD);
118: goto loop;
119: }
120: if (vget(ITOV(ip)))
121: goto loop;
122: *ipp = ip;
123: return(0);
124: }
125: /*
126: * Allocate a new inode.
127: */
128: if (error = getnewvnode(VT_UFS, mntp, &ufs_vnodeops, &nvp)) {
129: *ipp = 0;
130: return (error);
131: }
132: ip = VTOI(nvp);
133: ip->i_vnode = nvp;
134: ip->i_flag = 0;
135: ip->i_devvp = 0;
136: ip->i_mode = 0;
137: ip->i_diroff = 0;
138: ip->i_lockf = 0;
139: #ifdef QUOTA
140: for (i = 0; i < MAXQUOTAS; i++)
141: ip->i_dquot[i] = NODQUOT;
142: #endif
143: /*
144: * Put it onto its hash chain and lock it so that other requests for
145: * this inode will block if they arrive while we are sleeping waiting
146: * for old data structures to be purged or for the contents of the
147: * disk portion of this inode to be read.
148: */
149: ip->i_dev = dev;
150: ip->i_number = ino;
151: insque(ip, ih);
152: ILOCK(ip);
153: /*
154: * Read in the disk contents for the inode.
155: */
156: if (error = bread(VFSTOUFS(mntp)->um_devvp, fsbtodb(fs, itod(fs, ino)),
157: (int)fs->fs_bsize, NOCRED, &bp)) {
158: /*
159: * The inode does not contain anything useful, so it would
160: * be misleading to leave it on its hash chain.
161: * Iput() will take care of putting it back on the free list.
162: */
163: remque(ip);
164: ip->i_forw = ip;
165: ip->i_back = ip;
166: /*
167: * Unlock and discard unneeded inode.
168: */
169: iput(ip);
170: brelse(bp);
171: *ipp = 0;
172: return (error);
173: }
174: dp = bp->b_un.b_dino;
175: dp += itoo(fs, ino);
176: ip->i_din = *dp;
177: brelse(bp);
178: /*
179: * Initialize the associated vnode
180: */
181: vp = ITOV(ip);
182: vp->v_type = IFTOVT(ip->i_mode);
183: if (vp->v_type == VFIFO) {
184: #ifdef FIFO
185: extern struct vnodeops fifo_inodeops;
186: vp->v_op = &fifo_inodeops;
187: #else
188: iput(ip);
189: *ipp = 0;
190: return (EOPNOTSUPP);
191: #endif /* FIFO */
192: }
193: if (vp->v_type == VCHR || vp->v_type == VBLK) {
194: vp->v_op = &spec_inodeops;
195: if (nvp = checkalias(vp, ip->i_rdev, mntp)) {
196: /*
197: * Reinitialize aliased inode.
198: */
199: vp = nvp;
200: iq = VTOI(vp);
201: iq->i_vnode = vp;
202: iq->i_flag = 0;
203: ILOCK(iq);
204: iq->i_din = ip->i_din;
205: iq->i_dev = dev;
206: iq->i_number = ino;
207: insque(iq, ih);
208: /*
209: * Discard unneeded vnode
210: */
211: ip->i_mode = 0;
212: iput(ip);
213: ip = iq;
214: }
215: }
216: if (ino == ROOTINO)
217: vp->v_flag |= VROOT;
218: /*
219: * Finish inode initialization.
220: */
221: ip->i_fs = fs;
222: ip->i_devvp = VFSTOUFS(mntp)->um_devvp;
223: VREF(ip->i_devvp);
224: /*
225: * Set up a generation number for this inode if it does not
226: * already have one. This should only happen on old filesystems.
227: */
228: if (ip->i_gen == 0) {
229: if (++nextgennumber < (u_long)time.tv_sec)
230: nextgennumber = time.tv_sec;
231: ip->i_gen = nextgennumber;
232: if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
233: ip->i_flag |= IMOD;
234: }
235: *ipp = ip;
236: return (0);
237: }
238:
239: /*
240: * Unlock and decrement the reference count of an inode structure.
241: */
242: iput(ip)
243: register struct inode *ip;
244: {
245:
246: if ((ip->i_flag & ILOCKED) == 0)
247: panic("iput");
248: IUNLOCK(ip);
249: vrele(ITOV(ip));
250: }
251:
252: /*
253: * Last reference to an inode, write the inode out and if necessary,
254: * truncate and deallocate the file.
255: */
256: ufs_inactive(vp, p)
257: struct vnode *vp;
258: struct proc *p;
259: {
260: register struct inode *ip = VTOI(vp);
261: int mode, error = 0;
262:
263: if (prtactive && vp->v_usecount != 0)
264: vprint("ufs_inactive: pushing active", vp);
265: /*
266: * Get rid of inodes related to stale file handles.
267: */
268: if (ip->i_mode == 0) {
269: if ((vp->v_flag & VXLOCK) == 0)
270: vgone(vp);
271: return (0);
272: }
273: ILOCK(ip);
274: if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
275: #ifdef QUOTA
276: if (!getinoquota(ip))
277: (void) chkiq(ip, -1, NOCRED, 0);
278: #endif
279: error = itrunc(ip, (u_long)0, 0);
280: mode = ip->i_mode;
281: ip->i_mode = 0;
282: ip->i_rdev = 0;
283: ip->i_flag |= IUPD|ICHG;
284: ifree(ip, ip->i_number, mode);
285: }
286: IUPDAT(ip, &time, &time, 0);
287: IUNLOCK(ip);
288: ip->i_flag = 0;
289: /*
290: * If we are done with the inode, reclaim it
291: * so that it can be reused immediately.
292: */
293: if (vp->v_usecount == 0 && ip->i_mode == 0)
294: vgone(vp);
295: return (error);
296: }
297:
298: /*
299: * Reclaim an inode so that it can be used for other purposes.
300: */
301: ufs_reclaim(vp)
302: register struct vnode *vp;
303: {
304: register struct inode *ip = VTOI(vp);
305: int i;
306:
307: if (prtactive && vp->v_usecount != 0)
308: vprint("ufs_reclaim: pushing active", vp);
309: /*
310: * Remove the inode from its hash chain.
311: */
312: remque(ip);
313: ip->i_forw = ip;
314: ip->i_back = ip;
315: /*
316: * Purge old data structures associated with the inode.
317: */
318: cache_purge(vp);
319: if (ip->i_devvp) {
320: vrele(ip->i_devvp);
321: ip->i_devvp = 0;
322: }
323: #ifdef QUOTA
324: for (i = 0; i < MAXQUOTAS; i++) {
325: if (ip->i_dquot[i] != NODQUOT) {
326: dqrele(vp, ip->i_dquot[i]);
327: ip->i_dquot[i] = NODQUOT;
328: }
329: }
330: #endif
331: ip->i_flag = 0;
332: return (0);
333: }
334:
335: /*
336: * Update the access, modified, and inode change times as specified
337: * by the IACC, IMOD, and ICHG flags respectively. The IUPD flag
338: * is used to specify that the inode needs to be updated but that
339: * the times have already been set. The access and modified times
340: * are taken from the second and third parameters; the inode change
341: * time is always taken from the current time. If waitfor is set,
342: * then wait for the disk write of the inode to complete.
343: */
344: iupdat(ip, ta, tm, waitfor)
345: register struct inode *ip;
346: struct timeval *ta, *tm;
347: int waitfor;
348: {
349: struct buf *bp;
350: struct vnode *vp = ITOV(ip);
351: struct dinode *dp;
352: register struct fs *fs;
353: int error;
354:
355: fs = ip->i_fs;
356: if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
357: return (0);
358: if (vp->v_mount->mnt_flag & MNT_RDONLY)
359: return (0);
360: error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
361: (int)fs->fs_bsize, NOCRED, &bp);
362: if (error) {
363: brelse(bp);
364: return (error);
365: }
366: if (ip->i_flag&IACC)
367: ip->i_atime = ta->tv_sec;
368: if (ip->i_flag&IUPD)
369: ip->i_mtime = tm->tv_sec;
370: if (ip->i_flag&ICHG)
371: ip->i_ctime = time.tv_sec;
372: ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
373: dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
374: *dp = ip->i_din;
375: if (waitfor) {
376: return (bwrite(bp));
377: } else {
378: bdwrite(bp);
379: return (0);
380: }
381: }
382:
383: #define SINGLE 0 /* index of single indirect block */
384: #define DOUBLE 1 /* index of double indirect block */
385: #define TRIPLE 2 /* index of triple indirect block */
386: /*
387: * Truncate the inode ip to at most length size. Free affected disk
388: * blocks -- the blocks of the file are removed in reverse order.
389: *
390: * NB: triple indirect blocks are untested.
391: */
392: itrunc(oip, length, flags)
393: register struct inode *oip;
394: u_long length;
395: int flags;
396: {
397: register daddr_t lastblock;
398: daddr_t bn, lbn, lastiblock[NIADDR];
399: register struct fs *fs;
400: register struct inode *ip;
401: struct buf *bp;
402: int offset, osize, size, level;
403: long count, nblocks, blocksreleased = 0;
404: register int i;
405: int aflags, error, allerror;
406: struct inode tip;
407:
408: vnode_pager_setsize(ITOV(oip), length);
409: if (oip->i_size <= length) {
410: oip->i_flag |= ICHG|IUPD;
411: error = iupdat(oip, &time, &time, 1);
412: return (error);
413: }
414: /*
415: * Calculate index into inode's block list of
416: * last direct and indirect blocks (if any)
417: * which we want to keep. Lastblock is -1 when
418: * the file is truncated to 0.
419: */
420: fs = oip->i_fs;
421: lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
422: lastiblock[SINGLE] = lastblock - NDADDR;
423: lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
424: lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
425: nblocks = btodb(fs->fs_bsize);
426: /*
427: * Update the size of the file. If the file is not being
428: * truncated to a block boundry, the contents of the
429: * partial block following the end of the file must be
430: * zero'ed in case it ever become accessable again because
431: * of subsequent file growth.
432: */
433: osize = oip->i_size;
434: offset = blkoff(fs, length);
435: if (offset == 0) {
436: oip->i_size = length;
437: } else {
438: lbn = lblkno(fs, length);
439: aflags = B_CLRBUF;
440: if (flags & IO_SYNC)
441: aflags |= B_SYNC;
442: #ifdef QUOTA
443: if (error = getinoquota(oip))
444: return (error);
445: #endif
446: if (error = balloc(oip, lbn, offset, &bp, aflags))
447: return (error);
448: oip->i_size = length;
449: size = blksize(fs, oip, lbn);
450: (void) vnode_pager_uncache(ITOV(oip));
451: bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
452: allocbuf(bp, size);
453: if (flags & IO_SYNC)
454: bwrite(bp);
455: else
456: bdwrite(bp);
457: }
458: /*
459: * Update file and block pointers
460: * on disk before we start freeing blocks.
461: * If we crash before free'ing blocks below,
462: * the blocks will be returned to the free list.
463: * lastiblock values are also normalized to -1
464: * for calls to indirtrunc below.
465: */
466: tip = *oip;
467: tip.i_size = osize;
468: for (level = TRIPLE; level >= SINGLE; level--)
469: if (lastiblock[level] < 0) {
470: oip->i_ib[level] = 0;
471: lastiblock[level] = -1;
472: }
473: for (i = NDADDR - 1; i > lastblock; i--)
474: oip->i_db[i] = 0;
475: oip->i_flag |= ICHG|IUPD;
476: vinvalbuf(ITOV(oip), (length > 0));
477: allerror = iupdat(oip, &time, &time, MNT_WAIT);
478:
479: /*
480: * Indirect blocks first.
481: */
482: ip = &tip;
483: for (level = TRIPLE; level >= SINGLE; level--) {
484: bn = ip->i_ib[level];
485: if (bn != 0) {
486: error = indirtrunc(ip, bn, lastiblock[level], level,
487: &count);
488: if (error)
489: allerror = error;
490: blocksreleased += count;
491: if (lastiblock[level] < 0) {
492: ip->i_ib[level] = 0;
493: blkfree(ip, bn, (off_t)fs->fs_bsize);
494: blocksreleased += nblocks;
495: }
496: }
497: if (lastiblock[level] >= 0)
498: goto done;
499: }
500:
501: /*
502: * All whole direct blocks or frags.
503: */
504: for (i = NDADDR - 1; i > lastblock; i--) {
505: register off_t bsize;
506:
507: bn = ip->i_db[i];
508: if (bn == 0)
509: continue;
510: ip->i_db[i] = 0;
511: bsize = (off_t)blksize(fs, ip, i);
512: blkfree(ip, bn, bsize);
513: blocksreleased += btodb(bsize);
514: }
515: if (lastblock < 0)
516: goto done;
517:
518: /*
519: * Finally, look for a change in size of the
520: * last direct block; release any frags.
521: */
522: bn = ip->i_db[lastblock];
523: if (bn != 0) {
524: off_t oldspace, newspace;
525:
526: /*
527: * Calculate amount of space we're giving
528: * back as old block size minus new block size.
529: */
530: oldspace = blksize(fs, ip, lastblock);
531: ip->i_size = length;
532: newspace = blksize(fs, ip, lastblock);
533: if (newspace == 0)
534: panic("itrunc: newspace");
535: if (oldspace - newspace > 0) {
536: /*
537: * Block number of space to be free'd is
538: * the old block # plus the number of frags
539: * required for the storage we're keeping.
540: */
541: bn += numfrags(fs, newspace);
542: blkfree(ip, bn, oldspace - newspace);
543: blocksreleased += btodb(oldspace - newspace);
544: }
545: }
546: done:
547: /* BEGIN PARANOIA */
548: for (level = SINGLE; level <= TRIPLE; level++)
549: if (ip->i_ib[level] != oip->i_ib[level])
550: panic("itrunc1");
551: for (i = 0; i < NDADDR; i++)
552: if (ip->i_db[i] != oip->i_db[i])
553: panic("itrunc2");
554: /* END PARANOIA */
555: oip->i_blocks -= blocksreleased;
556: if (oip->i_blocks < 0) /* sanity */
557: oip->i_blocks = 0;
558: oip->i_flag |= ICHG;
559: #ifdef QUOTA
560: if (!getinoquota(oip))
561: (void) chkdq(oip, -blocksreleased, NOCRED, 0);
562: #endif
563: return (allerror);
564: }
565:
566: /*
567: * Release blocks associated with the inode ip and
568: * stored in the indirect block bn. Blocks are free'd
569: * in LIFO order up to (but not including) lastbn. If
570: * level is greater than SINGLE, the block is an indirect
571: * block and recursive calls to indirtrunc must be used to
572: * cleanse other indirect blocks.
573: *
574: * NB: triple indirect blocks are untested.
575: */
576: indirtrunc(ip, bn, lastbn, level, countp)
577: register struct inode *ip;
578: daddr_t bn, lastbn;
579: int level;
580: long *countp;
581: {
582: register int i;
583: struct buf *bp;
584: register struct fs *fs = ip->i_fs;
585: register daddr_t *bap;
586: daddr_t *copy, nb, last;
587: long blkcount, factor;
588: int nblocks, blocksreleased = 0;
589: int error, allerror = 0;
590:
591: /*
592: * Calculate index in current block of last
593: * block to be kept. -1 indicates the entire
594: * block so we need not calculate the index.
595: */
596: factor = 1;
597: for (i = SINGLE; i < level; i++)
598: factor *= NINDIR(fs);
599: last = lastbn;
600: if (lastbn > 0)
601: last /= factor;
602: nblocks = btodb(fs->fs_bsize);
603: /*
604: * Get buffer of block pointers, zero those
605: * entries corresponding to blocks to be free'd,
606: * and update on disk copy first.
607: */
608: error = bread(ip->i_devvp, fsbtodb(fs, bn), (int)fs->fs_bsize,
609: NOCRED, &bp);
610: if (error) {
611: brelse(bp);
612: *countp = 0;
613: return (error);
614: }
615: bap = bp->b_un.b_daddr;
616: MALLOC(copy, daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK);
617: bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);
618: bzero((caddr_t)&bap[last + 1],
619: (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));
620: if (last == -1)
621: bp->b_flags |= B_INVAL;
622: error = bwrite(bp);
623: if (error)
624: allerror = error;
625: bap = copy;
626:
627: /*
628: * Recursively free totally unused blocks.
629: */
630: for (i = NINDIR(fs) - 1; i > last; i--) {
631: nb = bap[i];
632: if (nb == 0)
633: continue;
634: if (level > SINGLE) {
635: error = indirtrunc(ip, nb, (daddr_t)-1, level - 1,
636: &blkcount);
637: if (error)
638: allerror = error;
639: blocksreleased += blkcount;
640: }
641: blkfree(ip, nb, (off_t)fs->fs_bsize);
642: blocksreleased += nblocks;
643: }
644:
645: /*
646: * Recursively free last partial block.
647: */
648: if (level > SINGLE && lastbn >= 0) {
649: last = lastbn % factor;
650: nb = bap[i];
651: if (nb != 0) {
652: error = indirtrunc(ip, nb, last, level - 1, &blkcount);
653: if (error)
654: allerror = error;
655: blocksreleased += blkcount;
656: }
657: }
658: FREE(copy, M_TEMP);
659: *countp = blocksreleased;
660: return (allerror);
661: }
662:
663: /*
664: * Lock an inode. If its already locked, set the WANT bit and sleep.
665: */
666: ilock(ip)
667: register struct inode *ip;
668: {
669:
670: while (ip->i_flag & ILOCKED) {
671: ip->i_flag |= IWANT;
672: if (ip->i_spare0 == curproc->p_pid)
673: panic("locking against myself");
674: ip->i_spare1 = curproc->p_pid;
675: (void) sleep((caddr_t)ip, PINOD);
676: }
677: ip->i_spare1 = 0;
678: ip->i_spare0 = curproc->p_pid;
679: ip->i_flag |= ILOCKED;
680: }
681:
682: /*
683: * Unlock an inode. If WANT bit is on, wakeup.
684: */
685: iunlock(ip)
686: register struct inode *ip;
687: {
688:
689: if ((ip->i_flag & ILOCKED) == 0)
690: vprint("iunlock: unlocked inode", ITOV(ip));
691: ip->i_spare0 = 0;
692: ip->i_flag &= ~ILOCKED;
693: if (ip->i_flag&IWANT) {
694: ip->i_flag &= ~IWANT;
695: wakeup((caddr_t)ip);
696: }
697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.