Correct .gbs.conf settings
[platform/adaptation/renesas_rcar/renesas_kernel.git] / fs / xfs / xfs_symlink.c
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * Copyright (c) 2012-2013 Red Hat, Inc.
4  * All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it would be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write the Free Software Foundation,
17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18  */
19 #include "xfs.h"
20 #include "xfs_shared.h"
21 #include "xfs_fs.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
25 #include "xfs_bit.h"
26 #include "xfs_sb.h"
27 #include "xfs_ag.h"
28 #include "xfs_mount.h"
29 #include "xfs_da_format.h"
30 #include "xfs_dir2.h"
31 #include "xfs_inode.h"
32 #include "xfs_ialloc.h"
33 #include "xfs_alloc.h"
34 #include "xfs_bmap.h"
35 #include "xfs_bmap_btree.h"
36 #include "xfs_bmap_util.h"
37 #include "xfs_error.h"
38 #include "xfs_quota.h"
39 #include "xfs_trans_space.h"
40 #include "xfs_trace.h"
41 #include "xfs_symlink.h"
42 #include "xfs_trans.h"
43 #include "xfs_log.h"
44 #include "xfs_dinode.h"
45
46 /* ----- Kernel only functions below ----- */
47 STATIC int
48 xfs_readlink_bmap(
49         struct xfs_inode        *ip,
50         char                    *link)
51 {
52         struct xfs_mount        *mp = ip->i_mount;
53         struct xfs_bmbt_irec    mval[XFS_SYMLINK_MAPS];
54         struct xfs_buf          *bp;
55         xfs_daddr_t             d;
56         char                    *cur_chunk;
57         int                     pathlen = ip->i_d.di_size;
58         int                     nmaps = XFS_SYMLINK_MAPS;
59         int                     byte_cnt;
60         int                     n;
61         int                     error = 0;
62         int                     fsblocks = 0;
63         int                     offset;
64
65         fsblocks = xfs_symlink_blocks(mp, pathlen);
66         error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0);
67         if (error)
68                 goto out;
69
70         offset = 0;
71         for (n = 0; n < nmaps; n++) {
72                 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
73                 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
74
75                 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0,
76                                   &xfs_symlink_buf_ops);
77                 if (!bp)
78                         return XFS_ERROR(ENOMEM);
79                 error = bp->b_error;
80                 if (error) {
81                         xfs_buf_ioerror_alert(bp, __func__);
82                         xfs_buf_relse(bp);
83                         goto out;
84                 }
85                 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
86                 if (pathlen < byte_cnt)
87                         byte_cnt = pathlen;
88
89                 cur_chunk = bp->b_addr;
90                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
91                         if (!xfs_symlink_hdr_ok(mp, ip->i_ino, offset,
92                                                         byte_cnt, bp)) {
93                                 error = EFSCORRUPTED;
94                                 xfs_alert(mp,
95 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)",
96                                         offset, byte_cnt, ip->i_ino);
97                                 xfs_buf_relse(bp);
98                                 goto out;
99
100                         }
101
102                         cur_chunk += sizeof(struct xfs_dsymlink_hdr);
103                 }
104
105                 memcpy(link + offset, bp->b_addr, byte_cnt);
106
107                 pathlen -= byte_cnt;
108                 offset += byte_cnt;
109
110                 xfs_buf_relse(bp);
111         }
112         ASSERT(pathlen == 0);
113
114         link[ip->i_d.di_size] = '\0';
115         error = 0;
116
117  out:
118         return error;
119 }
120
121 int
122 xfs_readlink(
123         struct xfs_inode *ip,
124         char            *link)
125 {
126         struct xfs_mount *mp = ip->i_mount;
127         xfs_fsize_t     pathlen;
128         int             error = 0;
129
130         trace_xfs_readlink(ip);
131
132         if (XFS_FORCED_SHUTDOWN(mp))
133                 return XFS_ERROR(EIO);
134
135         xfs_ilock(ip, XFS_ILOCK_SHARED);
136
137         pathlen = ip->i_d.di_size;
138         if (!pathlen)
139                 goto out;
140
141         if (pathlen < 0 || pathlen > MAXPATHLEN) {
142                 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
143                          __func__, (unsigned long long) ip->i_ino,
144                          (long long) pathlen);
145                 ASSERT(0);
146                 error = XFS_ERROR(EFSCORRUPTED);
147                 goto out;
148         }
149
150
151         if (ip->i_df.if_flags & XFS_IFINLINE) {
152                 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
153                 link[pathlen] = '\0';
154         } else {
155                 error = xfs_readlink_bmap(ip, link);
156         }
157
158  out:
159         xfs_iunlock(ip, XFS_ILOCK_SHARED);
160         return error;
161 }
162
163 int
164 xfs_symlink(
165         struct xfs_inode        *dp,
166         struct xfs_name         *link_name,
167         const char              *target_path,
168         umode_t                 mode,
169         struct xfs_inode        **ipp)
170 {
171         struct xfs_mount        *mp = dp->i_mount;
172         struct xfs_trans        *tp = NULL;
173         struct xfs_inode        *ip = NULL;
174         int                     error = 0;
175         int                     pathlen;
176         struct xfs_bmap_free    free_list;
177         xfs_fsblock_t           first_block;
178         bool                    unlock_dp_on_error = false;
179         uint                    cancel_flags;
180         int                     committed;
181         xfs_fileoff_t           first_fsb;
182         xfs_filblks_t           fs_blocks;
183         int                     nmaps;
184         struct xfs_bmbt_irec    mval[XFS_SYMLINK_MAPS];
185         xfs_daddr_t             d;
186         const char              *cur_chunk;
187         int                     byte_cnt;
188         int                     n;
189         xfs_buf_t               *bp;
190         prid_t                  prid;
191         struct xfs_dquot        *udqp = NULL;
192         struct xfs_dquot        *gdqp = NULL;
193         struct xfs_dquot        *pdqp = NULL;
194         uint                    resblks;
195
196         *ipp = NULL;
197
198         trace_xfs_symlink(dp, link_name);
199
200         if (XFS_FORCED_SHUTDOWN(mp))
201                 return XFS_ERROR(EIO);
202
203         /*
204          * Check component lengths of the target path name.
205          */
206         pathlen = strlen(target_path);
207         if (pathlen >= MAXPATHLEN)      /* total string too long */
208                 return XFS_ERROR(ENAMETOOLONG);
209
210         udqp = gdqp = NULL;
211         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
212                 prid = xfs_get_projid(dp);
213         else
214                 prid = XFS_PROJID_DEFAULT;
215
216         /*
217          * Make sure that we have allocated dquot(s) on disk.
218          */
219         error = xfs_qm_vop_dqalloc(dp,
220                         xfs_kuid_to_uid(current_fsuid()),
221                         xfs_kgid_to_gid(current_fsgid()), prid,
222                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,
223                         &udqp, &gdqp, &pdqp);
224         if (error)
225                 goto std_return;
226
227         tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
228         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
229         /*
230          * The symlink will fit into the inode data fork?
231          * There can't be any attributes so we get the whole variable part.
232          */
233         if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version))
234                 fs_blocks = 0;
235         else
236                 fs_blocks = xfs_symlink_blocks(mp, pathlen);
237         resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
238         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
239         if (error == ENOSPC && fs_blocks == 0) {
240                 resblks = 0;
241                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
242         }
243         if (error) {
244                 cancel_flags = 0;
245                 goto error_return;
246         }
247
248         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
249         unlock_dp_on_error = true;
250
251         /*
252          * Check whether the directory allows new symlinks or not.
253          */
254         if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
255                 error = XFS_ERROR(EPERM);
256                 goto error_return;
257         }
258
259         /*
260          * Reserve disk quota : blocks and inode.
261          */
262         error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,
263                                                 pdqp, resblks, 1, 0);
264         if (error)
265                 goto error_return;
266
267         /*
268          * Check for ability to enter directory entry, if no space reserved.
269          */
270         error = xfs_dir_canenter(tp, dp, link_name, resblks);
271         if (error)
272                 goto error_return;
273         /*
274          * Initialize the bmap freelist prior to calling either
275          * bmapi or the directory create code.
276          */
277         xfs_bmap_init(&free_list, &first_block);
278
279         /*
280          * Allocate an inode for the symlink.
281          */
282         error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
283                                prid, resblks > 0, &ip, NULL);
284         if (error) {
285                 if (error == ENOSPC)
286                         goto error_return;
287                 goto error1;
288         }
289
290         /*
291          * An error after we've joined dp to the transaction will result in the
292          * transaction cancel unlocking dp so don't do it explicitly in the
293          * error path.
294          */
295         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
296         unlock_dp_on_error = false;
297
298         /*
299          * Also attach the dquot(s) to it, if applicable.
300          */
301         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
302
303         if (resblks)
304                 resblks -= XFS_IALLOC_SPACE_RES(mp);
305         /*
306          * If the symlink will fit into the inode, write it inline.
307          */
308         if (pathlen <= XFS_IFORK_DSIZE(ip)) {
309                 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
310                 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
311                 ip->i_d.di_size = pathlen;
312
313                 /*
314                  * The inode was initially created in extent format.
315                  */
316                 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
317                 ip->i_df.if_flags |= XFS_IFINLINE;
318
319                 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
320                 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
321
322         } else {
323                 int     offset;
324
325                 first_fsb = 0;
326                 nmaps = XFS_SYMLINK_MAPS;
327
328                 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
329                                   XFS_BMAPI_METADATA, &first_block, resblks,
330                                   mval, &nmaps, &free_list);
331                 if (error)
332                         goto error2;
333
334                 if (resblks)
335                         resblks -= fs_blocks;
336                 ip->i_d.di_size = pathlen;
337                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
338
339                 cur_chunk = target_path;
340                 offset = 0;
341                 for (n = 0; n < nmaps; n++) {
342                         char    *buf;
343
344                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
345                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
346                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
347                                                BTOBB(byte_cnt), 0);
348                         if (!bp) {
349                                 error = ENOMEM;
350                                 goto error2;
351                         }
352                         bp->b_ops = &xfs_symlink_buf_ops;
353
354                         byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);
355                         byte_cnt = min(byte_cnt, pathlen);
356
357                         buf = bp->b_addr;
358                         buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset,
359                                                    byte_cnt, bp);
360
361                         memcpy(buf, cur_chunk, byte_cnt);
362
363                         cur_chunk += byte_cnt;
364                         pathlen -= byte_cnt;
365                         offset += byte_cnt;
366
367                         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);
368                         xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) -
369                                                         (char *)bp->b_addr);
370                 }
371                 ASSERT(pathlen == 0);
372         }
373
374         /*
375          * Create the directory entry for the symlink.
376          */
377         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
378                                         &first_block, &free_list, resblks);
379         if (error)
380                 goto error2;
381         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
382         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
383
384         /*
385          * If this is a synchronous mount, make sure that the
386          * symlink transaction goes to disk before returning to
387          * the user.
388          */
389         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
390                 xfs_trans_set_sync(tp);
391         }
392
393         error = xfs_bmap_finish(&tp, &free_list, &committed);
394         if (error) {
395                 goto error2;
396         }
397         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
398         xfs_qm_dqrele(udqp);
399         xfs_qm_dqrele(gdqp);
400         xfs_qm_dqrele(pdqp);
401
402         *ipp = ip;
403         return 0;
404
405  error2:
406         IRELE(ip);
407  error1:
408         xfs_bmap_cancel(&free_list);
409         cancel_flags |= XFS_TRANS_ABORT;
410  error_return:
411         xfs_trans_cancel(tp, cancel_flags);
412         xfs_qm_dqrele(udqp);
413         xfs_qm_dqrele(gdqp);
414         xfs_qm_dqrele(pdqp);
415
416         if (unlock_dp_on_error)
417                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
418  std_return:
419         return error;
420 }
421
422 /*
423  * Free a symlink that has blocks associated with it.
424  */
425 STATIC int
426 xfs_inactive_symlink_rmt(
427         struct xfs_inode *ip)
428 {
429         xfs_buf_t       *bp;
430         int             committed;
431         int             done;
432         int             error;
433         xfs_fsblock_t   first_block;
434         xfs_bmap_free_t free_list;
435         int             i;
436         xfs_mount_t     *mp;
437         xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
438         int             nmaps;
439         int             size;
440         xfs_trans_t     *tp;
441
442         mp = ip->i_mount;
443         ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
444         /*
445          * We're freeing a symlink that has some
446          * blocks allocated to it.  Free the
447          * blocks here.  We know that we've got
448          * either 1 or 2 extents and that we can
449          * free them all in one bunmapi call.
450          */
451         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
452
453         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
454         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
455         if (error) {
456                 xfs_trans_cancel(tp, 0);
457                 return error;
458         }
459
460         xfs_ilock(ip, XFS_ILOCK_EXCL);
461         xfs_trans_ijoin(tp, ip, 0);
462
463         /*
464          * Lock the inode, fix the size, and join it to the transaction.
465          * Hold it so in the normal path, we still have it locked for
466          * the second transaction.  In the error paths we need it
467          * held so the cancel won't rele it, see below.
468          */
469         size = (int)ip->i_d.di_size;
470         ip->i_d.di_size = 0;
471         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
472         /*
473          * Find the block(s) so we can inval and unmap them.
474          */
475         done = 0;
476         xfs_bmap_init(&free_list, &first_block);
477         nmaps = ARRAY_SIZE(mval);
478         error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
479                                 mval, &nmaps, 0);
480         if (error)
481                 goto error_trans_cancel;
482         /*
483          * Invalidate the block(s). No validation is done.
484          */
485         for (i = 0; i < nmaps; i++) {
486                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
487                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
488                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
489                 if (!bp) {
490                         error = ENOMEM;
491                         goto error_bmap_cancel;
492                 }
493                 xfs_trans_binval(tp, bp);
494         }
495         /*
496          * Unmap the dead block(s) to the free_list.
497          */
498         error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
499                             &first_block, &free_list, &done);
500         if (error)
501                 goto error_bmap_cancel;
502         ASSERT(done);
503         /*
504          * Commit the first transaction.  This logs the EFI and the inode.
505          */
506         error = xfs_bmap_finish(&tp, &free_list, &committed);
507         if (error)
508                 goto error_bmap_cancel;
509         /*
510          * The transaction must have been committed, since there were
511          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
512          * The new tp has the extent freeing and EFDs.
513          */
514         ASSERT(committed);
515         /*
516          * The first xact was committed, so add the inode to the new one.
517          * Mark it dirty so it will be logged and moved forward in the log as
518          * part of every commit.
519          */
520         xfs_trans_ijoin(tp, ip, 0);
521         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
522         /*
523          * Commit the transaction containing extent freeing and EFDs.
524          */
525         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
526         if (error) {
527                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
528                 goto error_unlock;
529         }
530
531         /*
532          * Remove the memory for extent descriptions (just bookkeeping).
533          */
534         if (ip->i_df.if_bytes)
535                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
536         ASSERT(ip->i_df.if_bytes == 0);
537
538         xfs_iunlock(ip, XFS_ILOCK_EXCL);
539         return 0;
540
541 error_bmap_cancel:
542         xfs_bmap_cancel(&free_list);
543 error_trans_cancel:
544         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
545 error_unlock:
546         xfs_iunlock(ip, XFS_ILOCK_EXCL);
547         return error;
548 }
549
550 /*
551  * xfs_inactive_symlink - free a symlink
552  */
553 int
554 xfs_inactive_symlink(
555         struct xfs_inode        *ip)
556 {
557         struct xfs_mount        *mp = ip->i_mount;
558         int                     pathlen;
559
560         trace_xfs_inactive_symlink(ip);
561
562         if (XFS_FORCED_SHUTDOWN(mp))
563                 return XFS_ERROR(EIO);
564
565         xfs_ilock(ip, XFS_ILOCK_EXCL);
566
567         /*
568          * Zero length symlinks _can_ exist.
569          */
570         pathlen = (int)ip->i_d.di_size;
571         if (!pathlen) {
572                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
573                 return 0;
574         }
575
576         if (pathlen < 0 || pathlen > MAXPATHLEN) {
577                 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
578                          __func__, (unsigned long long)ip->i_ino, pathlen);
579                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
580                 ASSERT(0);
581                 return XFS_ERROR(EFSCORRUPTED);
582         }
583
584         if (ip->i_df.if_flags & XFS_IFINLINE) {
585                 if (ip->i_df.if_bytes > 0) 
586                         xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
587                                           XFS_DATA_FORK);
588                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
589                 ASSERT(ip->i_df.if_bytes == 0);
590                 return 0;
591         }
592
593         xfs_iunlock(ip, XFS_ILOCK_EXCL);
594
595         /* remove the remote symlink */
596         return xfs_inactive_symlink_rmt(ip);
597 }