1 /*
2 * Copyright (c) 2000-2002 Silicon Graphics, Inc. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22 *
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
25 *
26 * http://www.sgi.com
27 *
28 * For further information regarding this notice, see:
29 *
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31 */
32
33 #include "xfs.h"
34 #include "xfs_macros.h"
35 #include "xfs_types.h"
36 #include "xfs_inum.h"
37 #include "xfs_log.h"
38 #include "xfs_trans.h"
39 #include "xfs_sb.h"
40 #include "xfs_dir.h"
41 #include "xfs_dir2.h"
42 #include "xfs_dmapi.h"
43 #include "xfs_mount.h"
44 #include "xfs_bmap_btree.h"
45 #include "xfs_attr_sf.h"
46 #include "xfs_dir_sf.h"
47 #include "xfs_dir2_sf.h"
48 #include "xfs_dinode.h"
49 #include "xfs_inode_item.h"
50 #include "xfs_inode.h"
51 #include "xfs_bmap.h"
52 #include "xfs_error.h"
53 #include "xfs_quota.h"
54 #include "xfs_rw.h"
55 #include "xfs_itable.h"
56 #include "xfs_utils.h"
57
58 /*
59 * xfs_get_dir_entry is used to get a reference to an inode given
60 * its parent directory inode and the name of the file. It does
61 * not lock the child inode, and it unlocks the directory before
62 * returning. The directory's generation number is returned for
63 * use by a later call to xfs_lock_dir_and_entry.
64 */
65 int
66 xfs_get_dir_entry(
67 vname_t *dentry,
68 xfs_inode_t **ipp)
69 {
70 vnode_t *vp;
71 bhv_desc_t *bdp;
72
73 vp = VNAME_TO_VNODE(dentry);
74 bdp = vn_bhv_lookup_unlocked(VN_BHV_HEAD(vp), &xfs_vnodeops);
75 if (!bdp) {
76 *ipp = NULL;
77 return XFS_ERROR(ENOENT);
78 }
79 VN_HOLD(vp);
80 *ipp = XFS_BHVTOI(bdp);
81 return 0;
82 }
83
84 int
85 xfs_dir_lookup_int(
86 bhv_desc_t *dir_bdp,
87 uint lock_mode,
88 vname_t *dentry,
89 xfs_ino_t *inum,
90 xfs_inode_t **ipp)
91 {
92 vnode_t *dir_vp;
93 xfs_inode_t *dp;
94 int error;
95
96 dir_vp = BHV_TO_VNODE(dir_bdp);
97 vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
98
99 dp = XFS_BHVTOI(dir_bdp);
100
101 error = XFS_DIR_LOOKUP(dp->i_mount, NULL, dp,
102 VNAME(dentry), VNAMELEN(dentry), inum);
103 if (!error) {
104 /*
105 * Unlock the directory. We do this because we can't
106 * hold the directory lock while doing the vn_get()
107 * in xfs_iget(). Doing so could cause us to hold
108 * a lock while waiting for the inode to finish
109 * being inactive while it's waiting for a log
110 * reservation in the inactive routine.
111 */
112 xfs_iunlock(dp, lock_mode);
113 error = xfs_iget(dp->i_mount, NULL, *inum, 0, 0, ipp, 0);
114 xfs_ilock(dp, lock_mode);
115
116 if (error) {
117 *ipp = NULL;
118 } else if ((*ipp)->i_d.di_mode == 0) {
119 /*
120 * The inode has been freed. Something is
121 * wrong so just get out of here.
122 */
123 xfs_iunlock(dp, lock_mode);
124 xfs_iput_new(*ipp, 0);
125 *ipp = NULL;
126 xfs_ilock(dp, lock_mode);
127 error = XFS_ERROR(ENOENT);
128 }
129 }
130 return error;
131 }
132
133 /*
134 * Allocates a new inode from disk and return a pointer to the
135 * incore copy. This routine will internally commit the current
136 * transaction and allocate a new one if the Space Manager needed
137 * to do an allocation to replenish the inode free-list.
138 *
139 * This routine is designed to be called from xfs_create and
140 * xfs_create_dir.
141 *
142 */
143 int
144 xfs_dir_ialloc(
145 xfs_trans_t **tpp, /* input: current transaction;
146 output: may be a new transaction. */
147 xfs_inode_t *dp, /* directory within whose allocate
148 the inode. */
149 mode_t mode,
150 nlink_t nlink,
151 xfs_dev_t rdev,
152 cred_t *credp,
153 prid_t prid, /* project id */
154 int okalloc, /* ok to allocate new space */
155 xfs_inode_t **ipp, /* pointer to inode; it will be
156 locked. */
157 int *committed)
158
159 {
160 xfs_trans_t *tp;
161 xfs_trans_t *ntp;
162 xfs_inode_t *ip;
163 xfs_buf_t *ialloc_context = NULL;
164 boolean_t call_again = B_FALSE;
165 int code;
166 uint log_res;
167 uint log_count;
168 void *dqinfo;
169 uint tflags;
170
171 tp = *tpp;
172 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
173
174 /*
175 * xfs_ialloc will return a pointer to an incore inode if
176 * the Space Manager has an available inode on the free
177 * list. Otherwise, it will do an allocation and replenish
178 * the freelist. Since we can only do one allocation per
179 * transaction without deadlocks, we will need to commit the
180 * current transaction and start a new one. We will then
181 * need to call xfs_ialloc again to get the inode.
182 *
183 * If xfs_ialloc did an allocation to replenish the freelist,
184 * it returns the bp containing the head of the freelist as
185 * ialloc_context. We will hold a lock on it across the
186 * transaction commit so that no other process can steal
187 * the inode(s) that we've just allocated.
188 */
189 code = xfs_ialloc(tp, dp, mode, nlink, rdev, credp, prid, okalloc,
190 &ialloc_context, &call_again, &ip);
191
192 /*
193 * Return an error if we were unable to allocate a new inode.
194 * This should only happen if we run out of space on disk or
195 * encounter a disk error.
196 */
197 if (code) {
198 *ipp = NULL;
199 return code;
200 }
201 if (!call_again && (ip == NULL)) {
202 *ipp = NULL;
203 return XFS_ERROR(ENOSPC);
204 }
205
206 /*
207 * If call_again is set, then we were unable to get an
208 * inode in one operation. We need to commit the current
209 * transaction and call xfs_ialloc() again. It is guaranteed
210 * to succeed the second time.
211 */
212 if (call_again) {
213
214 /*
215 * Normally, xfs_trans_commit releases all the locks.
216 * We call bhold to hang on to the ialloc_context across
217 * the commit. Holding this buffer prevents any other
218 * processes from doing any allocations in this
219 * allocation group.
220 */
221 xfs_trans_bhold(tp, ialloc_context);
222 /*
223 * Save the log reservation so we can use
224 * them in the next transaction.
225 */
226 log_res = xfs_trans_get_log_res(tp);
227 log_count = xfs_trans_get_log_count(tp);
228
229 /*
230 * We want the quota changes to be associated with the next
231 * transaction, NOT this one. So, detach the dqinfo from this
232 * and attach it to the next transaction.
233 */
234 dqinfo = NULL;
235 tflags = 0;
236 if (tp->t_dqinfo) {
237 dqinfo = (void *)tp->t_dqinfo;
238 tp->t_dqinfo = NULL;
239 tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
240 tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
241 }
242
243 ntp = xfs_trans_dup(tp);
244 code = xfs_trans_commit(tp, 0, NULL);
245 tp = ntp;
246 if (committed != NULL) {
247 *committed = 1;
248 }
249 /*
250 * If we get an error during the commit processing,
251 * release the buffer that is still held and return
252 * to the caller.
253 */
254 if (code) {
255 xfs_buf_relse(ialloc_context);
256 if (dqinfo) {
257 tp->t_dqinfo = dqinfo;
258 XFS_TRANS_FREE_DQINFO(tp->t_mountp, tp);
259 }
260 *tpp = ntp;
261 *ipp = NULL;
262 return code;
263 }
264 code = xfs_trans_reserve(tp, 0, log_res, 0,
265 XFS_TRANS_PERM_LOG_RES, log_count);
266 /*
267 * Re-attach the quota info that we detached from prev trx.
268 */
269 if (dqinfo) {
270 tp->t_dqinfo = dqinfo;
271 tp->t_flags |= tflags;
272 }
273
274 if (code) {
275 xfs_buf_relse(ialloc_context);
276 *tpp = ntp;
277 *ipp = NULL;
278 return code;
279 }
280 xfs_trans_bjoin(tp, ialloc_context);
281
282 /*
283 * Call ialloc again. Since we've locked out all
284 * other allocations in this allocation group,
285 * this call should always succeed.
286 */
287 code = xfs_ialloc(tp, dp, mode, nlink, rdev, credp, prid,
288 okalloc, &ialloc_context, &call_again, &ip);
289
290 /*
291 * If we get an error at this point, return to the caller
292 * so that the current transaction can be aborted.
293 */
294 if (code) {
295 *tpp = tp;
296 *ipp = NULL;
297 return code;
298 }
299 ASSERT ((!call_again) && (ip != NULL));
300
301 } else {
302 if (committed != NULL) {
303 *committed = 0;
304 }
305 }
306
307 *ipp = ip;
308 *tpp = tp;
309
310 return 0;
311 }
312
313 /*
314 * Decrement the link count on an inode & log the change.
315 * If this causes the link count to go to zero, initiate the
316 * logging activity required to truncate a file.
317 */
318 int /* error */
319 xfs_droplink(
320 xfs_trans_t *tp,
321 xfs_inode_t *ip)
322 {
323 int error;
324
325 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
326
327 ASSERT (ip->i_d.di_nlink > 0);
328 ip->i_d.di_nlink--;
329 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
330
331 error = 0;
332 if (ip->i_d.di_nlink == 0) {
333 /*
334 * We're dropping the last link to this file.
335 * Move the on-disk inode to the AGI unlinked list.
336 * From xfs_inactive() we will pull the inode from
337 * the list and free it.
338 */
339 error = xfs_iunlink(tp, ip);
340 }
341 return error;
342 }
343
344 /*
345 * This gets called when the inode's version needs to be changed from 1 to 2.
346 * Currently this happens when the nlink field overflows the old 16-bit value
347 * or when chproj is called to change the project for the first time.
348 * As a side effect the superblock version will also get rev'd
349 * to contain the NLINK bit.
350 */
351 void
352 xfs_bump_ino_vers2(
353 xfs_trans_t *tp,
354 xfs_inode_t *ip)
355 {
356 xfs_mount_t *mp;
357 unsigned long s;
358
359 ASSERT(ismrlocked (&ip->i_lock, MR_UPDATE));
360 ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1);
361
362 ip->i_d.di_version = XFS_DINODE_VERSION_2;
363 ip->i_d.di_onlink = 0;
364 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
365 mp = tp->t_mountp;
366 if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
367 s = XFS_SB_LOCK(mp);
368 if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
369 XFS_SB_VERSION_ADDNLINK(&mp->m_sb);
370 XFS_SB_UNLOCK(mp, s);
371 xfs_mod_sb(tp, XFS_SB_VERSIONNUM);
372 } else {
373 XFS_SB_UNLOCK(mp, s);
374 }
375 }
376 /* Caller must log the inode */
377 }
378
379 /*
380 * Increment the link count on an inode & log the change.
381 */
382 int
383 xfs_bumplink(
384 xfs_trans_t *tp,
385 xfs_inode_t *ip)
386 {
387 if (ip->i_d.di_nlink >= XFS_MAXLINK)
388 return XFS_ERROR(EMLINK);
389 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
390
391 ASSERT(ip->i_d.di_nlink > 0);
392 ip->i_d.di_nlink++;
393 if ((ip->i_d.di_version == XFS_DINODE_VERSION_1) &&
394 (ip->i_d.di_nlink > XFS_MAXLINK_1)) {
395 /*
396 * The inode has increased its number of links beyond
397 * what can fit in an old format inode. It now needs
398 * to be converted to a version 2 inode with a 32 bit
399 * link count. If this is the first inode in the file
400 * system to do this, then we need to bump the superblock
401 * version number as well.
402 */
403 xfs_bump_ino_vers2(tp, ip);
404 }
405
406 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
407 return 0;
408 }
409
410 /*
411 * Try to truncate the given file to 0 length. Currently called
412 * only out of xfs_remove when it has to truncate a file to free
413 * up space for the remove to proceed.
414 */
415 int
416 xfs_truncate_file(
417 xfs_mount_t *mp,
418 xfs_inode_t *ip)
419 {
420 xfs_trans_t *tp;
421 int error;
422
423 #ifdef QUOTADEBUG
424 /*
425 * This is called to truncate the quotainodes too.
426 */
427 if (XFS_IS_UQUOTA_ON(mp)) {
428 if (ip->i_ino != mp->m_sb.sb_uquotino)
429 ASSERT(ip->i_udquot);
430 }
431 if (XFS_IS_GQUOTA_ON(mp)) {
432 if (ip->i_ino != mp->m_sb.sb_gquotino)
433 ASSERT(ip->i_gdquot);
434 }
435 #endif
436 /*
437 * Make the call to xfs_itruncate_start before starting the
438 * transaction, because we cannot make the call while we're
439 * in a transaction.
440 */
441 xfs_ilock(ip, XFS_IOLOCK_EXCL);
442 xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, (xfs_fsize_t)0);
443
444 tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
445 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
446 XFS_TRANS_PERM_LOG_RES,
447 XFS_ITRUNCATE_LOG_COUNT))) {
448 xfs_trans_cancel(tp, 0);
449 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
450 return error;
451 }
452
453 /*
454 * Follow the normal truncate locking protocol. Since we
455 * hold the inode in the transaction, we know that it's number
456 * of references will stay constant.
457 */
458 xfs_ilock(ip, XFS_ILOCK_EXCL);
459 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
460 xfs_trans_ihold(tp, ip);
461 /*
462 * Signal a sync xaction. The only case where that isn't
463 * the case is if we're truncating an already unlinked file
464 * on a wsync fs. In that case, we know the blocks can't
465 * reappear in the file because the links to file are
466 * permanently toast. Currently, we're always going to
467 * want a sync transaction because this code is being
468 * called from places where nlink is guaranteed to be 1
469 * but I'm leaving the tests in to protect against future
470 * changes -- rcc.
471 */
472 error = xfs_itruncate_finish(&tp, ip, (xfs_fsize_t)0,
473 XFS_DATA_FORK,
474 ((ip->i_d.di_nlink != 0 ||
475 !(mp->m_flags & XFS_MOUNT_WSYNC))
476 ? 1 : 0));
477 if (error) {
478 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
479 XFS_TRANS_ABORT);
480 } else {
481 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
482 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES,
483 NULL);
484 }
485 xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
486
487 return error;
488 }
489
|
This page was automatically generated by the
LXR engine.
|