Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * (C) 2001 Clemson University and The University of Chicago
0004  * Copyright 2018 Omnibond Systems, L.L.C.
0005  *
0006  * See COPYING in top-level directory.
0007  */
0008 
0009 /*
0010  *  Linux VFS inode operations.
0011  */
0012 
0013 #include <linux/blkdev.h>
0014 #include <linux/fileattr.h>
0015 #include "protocol.h"
0016 #include "orangefs-kernel.h"
0017 #include "orangefs-bufmap.h"
0018 
0019 static int orangefs_writepage_locked(struct page *page,
0020     struct writeback_control *wbc)
0021 {
0022     struct inode *inode = page->mapping->host;
0023     struct orangefs_write_range *wr = NULL;
0024     struct iov_iter iter;
0025     struct bio_vec bv;
0026     size_t len, wlen;
0027     ssize_t ret;
0028     loff_t off;
0029 
0030     set_page_writeback(page);
0031 
0032     len = i_size_read(inode);
0033     if (PagePrivate(page)) {
0034         wr = (struct orangefs_write_range *)page_private(page);
0035         WARN_ON(wr->pos >= len);
0036         off = wr->pos;
0037         if (off + wr->len > len)
0038             wlen = len - off;
0039         else
0040             wlen = wr->len;
0041     } else {
0042         WARN_ON(1);
0043         off = page_offset(page);
0044         if (off + PAGE_SIZE > len)
0045             wlen = len - off;
0046         else
0047             wlen = PAGE_SIZE;
0048     }
0049     /* Should've been handled in orangefs_invalidate_folio. */
0050     WARN_ON(off == len || off + wlen > len);
0051 
0052     bv.bv_page = page;
0053     bv.bv_len = wlen;
0054     bv.bv_offset = off % PAGE_SIZE;
0055     WARN_ON(wlen == 0);
0056     iov_iter_bvec(&iter, WRITE, &bv, 1, wlen);
0057 
0058     ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, wlen,
0059         len, wr, NULL, NULL);
0060     if (ret < 0) {
0061         SetPageError(page);
0062         mapping_set_error(page->mapping, ret);
0063     } else {
0064         ret = 0;
0065     }
0066     kfree(detach_page_private(page));
0067     return ret;
0068 }
0069 
0070 static int orangefs_writepage(struct page *page, struct writeback_control *wbc)
0071 {
0072     int ret;
0073     ret = orangefs_writepage_locked(page, wbc);
0074     unlock_page(page);
0075     end_page_writeback(page);
0076     return ret;
0077 }
0078 
0079 struct orangefs_writepages {
0080     loff_t off;
0081     size_t len;
0082     kuid_t uid;
0083     kgid_t gid;
0084     int maxpages;
0085     int npages;
0086     struct page **pages;
0087     struct bio_vec *bv;
0088 };
0089 
0090 static int orangefs_writepages_work(struct orangefs_writepages *ow,
0091     struct writeback_control *wbc)
0092 {
0093     struct inode *inode = ow->pages[0]->mapping->host;
0094     struct orangefs_write_range *wrp, wr;
0095     struct iov_iter iter;
0096     ssize_t ret;
0097     size_t len;
0098     loff_t off;
0099     int i;
0100 
0101     len = i_size_read(inode);
0102 
0103     for (i = 0; i < ow->npages; i++) {
0104         set_page_writeback(ow->pages[i]);
0105         ow->bv[i].bv_page = ow->pages[i];
0106         ow->bv[i].bv_len = min(page_offset(ow->pages[i]) + PAGE_SIZE,
0107             ow->off + ow->len) -
0108             max(ow->off, page_offset(ow->pages[i]));
0109         if (i == 0)
0110             ow->bv[i].bv_offset = ow->off -
0111                 page_offset(ow->pages[i]);
0112         else
0113             ow->bv[i].bv_offset = 0;
0114     }
0115     iov_iter_bvec(&iter, WRITE, ow->bv, ow->npages, ow->len);
0116 
0117     WARN_ON(ow->off >= len);
0118     if (ow->off + ow->len > len)
0119         ow->len = len - ow->off;
0120 
0121     off = ow->off;
0122     wr.uid = ow->uid;
0123     wr.gid = ow->gid;
0124     ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, ow->len,
0125         0, &wr, NULL, NULL);
0126     if (ret < 0) {
0127         for (i = 0; i < ow->npages; i++) {
0128             SetPageError(ow->pages[i]);
0129             mapping_set_error(ow->pages[i]->mapping, ret);
0130             if (PagePrivate(ow->pages[i])) {
0131                 wrp = (struct orangefs_write_range *)
0132                     page_private(ow->pages[i]);
0133                 ClearPagePrivate(ow->pages[i]);
0134                 put_page(ow->pages[i]);
0135                 kfree(wrp);
0136             }
0137             end_page_writeback(ow->pages[i]);
0138             unlock_page(ow->pages[i]);
0139         }
0140     } else {
0141         ret = 0;
0142         for (i = 0; i < ow->npages; i++) {
0143             if (PagePrivate(ow->pages[i])) {
0144                 wrp = (struct orangefs_write_range *)
0145                     page_private(ow->pages[i]);
0146                 ClearPagePrivate(ow->pages[i]);
0147                 put_page(ow->pages[i]);
0148                 kfree(wrp);
0149             }
0150             end_page_writeback(ow->pages[i]);
0151             unlock_page(ow->pages[i]);
0152         }
0153     }
0154     return ret;
0155 }
0156 
0157 static int orangefs_writepages_callback(struct page *page,
0158     struct writeback_control *wbc, void *data)
0159 {
0160     struct orangefs_writepages *ow = data;
0161     struct orangefs_write_range *wr;
0162     int ret;
0163 
0164     if (!PagePrivate(page)) {
0165         unlock_page(page);
0166         /* It's not private so there's nothing to write, right? */
0167         printk("writepages_callback not private!\n");
0168         BUG();
0169         return 0;
0170     }
0171     wr = (struct orangefs_write_range *)page_private(page);
0172 
0173     ret = -1;
0174     if (ow->npages == 0) {
0175         ow->off = wr->pos;
0176         ow->len = wr->len;
0177         ow->uid = wr->uid;
0178         ow->gid = wr->gid;
0179         ow->pages[ow->npages++] = page;
0180         ret = 0;
0181         goto done;
0182     }
0183     if (!uid_eq(ow->uid, wr->uid) || !gid_eq(ow->gid, wr->gid)) {
0184         orangefs_writepages_work(ow, wbc);
0185         ow->npages = 0;
0186         ret = -1;
0187         goto done;
0188     }
0189     if (ow->off + ow->len == wr->pos) {
0190         ow->len += wr->len;
0191         ow->pages[ow->npages++] = page;
0192         ret = 0;
0193         goto done;
0194     }
0195 done:
0196     if (ret == -1) {
0197         if (ow->npages) {
0198             orangefs_writepages_work(ow, wbc);
0199             ow->npages = 0;
0200         }
0201         ret = orangefs_writepage_locked(page, wbc);
0202         mapping_set_error(page->mapping, ret);
0203         unlock_page(page);
0204         end_page_writeback(page);
0205     } else {
0206         if (ow->npages == ow->maxpages) {
0207             orangefs_writepages_work(ow, wbc);
0208             ow->npages = 0;
0209         }
0210     }
0211     return ret;
0212 }
0213 
0214 static int orangefs_writepages(struct address_space *mapping,
0215     struct writeback_control *wbc)
0216 {
0217     struct orangefs_writepages *ow;
0218     struct blk_plug plug;
0219     int ret;
0220     ow = kzalloc(sizeof(struct orangefs_writepages), GFP_KERNEL);
0221     if (!ow)
0222         return -ENOMEM;
0223     ow->maxpages = orangefs_bufmap_size_query()/PAGE_SIZE;
0224     ow->pages = kcalloc(ow->maxpages, sizeof(struct page *), GFP_KERNEL);
0225     if (!ow->pages) {
0226         kfree(ow);
0227         return -ENOMEM;
0228     }
0229     ow->bv = kcalloc(ow->maxpages, sizeof(struct bio_vec), GFP_KERNEL);
0230     if (!ow->bv) {
0231         kfree(ow->pages);
0232         kfree(ow);
0233         return -ENOMEM;
0234     }
0235     blk_start_plug(&plug);
0236     ret = write_cache_pages(mapping, wbc, orangefs_writepages_callback, ow);
0237     if (ow->npages)
0238         ret = orangefs_writepages_work(ow, wbc);
0239     blk_finish_plug(&plug);
0240     kfree(ow->pages);
0241     kfree(ow->bv);
0242     kfree(ow);
0243     return ret;
0244 }
0245 
0246 static int orangefs_launder_folio(struct folio *);
0247 
0248 static void orangefs_readahead(struct readahead_control *rac)
0249 {
0250     loff_t offset;
0251     struct iov_iter iter;
0252     struct inode *inode = rac->mapping->host;
0253     struct xarray *i_pages;
0254     struct page *page;
0255     loff_t new_start = readahead_pos(rac);
0256     int ret;
0257     size_t new_len = 0;
0258 
0259     loff_t bytes_remaining = inode->i_size - readahead_pos(rac);
0260     loff_t pages_remaining = bytes_remaining / PAGE_SIZE;
0261 
0262     if (pages_remaining >= 1024)
0263         new_len = 4194304;
0264     else if (pages_remaining > readahead_count(rac))
0265         new_len = bytes_remaining;
0266 
0267     if (new_len)
0268         readahead_expand(rac, new_start, new_len);
0269 
0270     offset = readahead_pos(rac);
0271     i_pages = &rac->mapping->i_pages;
0272 
0273     iov_iter_xarray(&iter, READ, i_pages, offset, readahead_length(rac));
0274 
0275     /* read in the pages. */
0276     if ((ret = wait_for_direct_io(ORANGEFS_IO_READ, inode,
0277             &offset, &iter, readahead_length(rac),
0278             inode->i_size, NULL, NULL, rac->file)) < 0)
0279         gossip_debug(GOSSIP_FILE_DEBUG,
0280             "%s: wait_for_direct_io failed. \n", __func__);
0281     else
0282         ret = 0;
0283 
0284     /* clean up. */
0285     while ((page = readahead_page(rac))) {
0286         page_endio(page, false, ret);
0287         put_page(page);
0288     }
0289 }
0290 
0291 static int orangefs_read_folio(struct file *file, struct folio *folio)
0292 {
0293     struct inode *inode = folio->mapping->host;
0294     struct iov_iter iter;
0295     struct bio_vec bv;
0296     ssize_t ret;
0297     loff_t off; /* offset of this folio in the file */
0298 
0299     if (folio_test_dirty(folio))
0300         orangefs_launder_folio(folio);
0301 
0302     off = folio_pos(folio);
0303     bv.bv_page = &folio->page;
0304     bv.bv_len = folio_size(folio);
0305     bv.bv_offset = 0;
0306     iov_iter_bvec(&iter, READ, &bv, 1, folio_size(folio));
0307 
0308     ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, &off, &iter,
0309             folio_size(folio), inode->i_size, NULL, NULL, file);
0310     /* this will only zero remaining unread portions of the folio data */
0311     iov_iter_zero(~0U, &iter);
0312     /* takes care of potential aliasing */
0313     flush_dcache_folio(folio);
0314     if (ret < 0) {
0315         folio_set_error(folio);
0316     } else {
0317         folio_mark_uptodate(folio);
0318         ret = 0;
0319     }
0320     /* unlock the folio after the ->read_folio() routine completes */
0321     folio_unlock(folio);
0322         return ret;
0323 }
0324 
0325 static int orangefs_write_begin(struct file *file,
0326         struct address_space *mapping, loff_t pos, unsigned len,
0327         struct page **pagep, void **fsdata)
0328 {
0329     struct orangefs_write_range *wr;
0330     struct folio *folio;
0331     struct page *page;
0332     pgoff_t index;
0333     int ret;
0334 
0335     index = pos >> PAGE_SHIFT;
0336 
0337     page = grab_cache_page_write_begin(mapping, index);
0338     if (!page)
0339         return -ENOMEM;
0340 
0341     *pagep = page;
0342     folio = page_folio(page);
0343 
0344     if (folio_test_dirty(folio) && !folio_test_private(folio)) {
0345         /*
0346          * Should be impossible.  If it happens, launder the page
0347          * since we don't know what's dirty.  This will WARN in
0348          * orangefs_writepage_locked.
0349          */
0350         ret = orangefs_launder_folio(folio);
0351         if (ret)
0352             return ret;
0353     }
0354     if (folio_test_private(folio)) {
0355         struct orangefs_write_range *wr;
0356         wr = folio_get_private(folio);
0357         if (wr->pos + wr->len == pos &&
0358             uid_eq(wr->uid, current_fsuid()) &&
0359             gid_eq(wr->gid, current_fsgid())) {
0360             wr->len += len;
0361             goto okay;
0362         } else {
0363             ret = orangefs_launder_folio(folio);
0364             if (ret)
0365                 return ret;
0366         }
0367     }
0368 
0369     wr = kmalloc(sizeof *wr, GFP_KERNEL);
0370     if (!wr)
0371         return -ENOMEM;
0372 
0373     wr->pos = pos;
0374     wr->len = len;
0375     wr->uid = current_fsuid();
0376     wr->gid = current_fsgid();
0377     folio_attach_private(folio, wr);
0378 okay:
0379     return 0;
0380 }
0381 
0382 static int orangefs_write_end(struct file *file, struct address_space *mapping,
0383     loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata)
0384 {
0385     struct inode *inode = page->mapping->host;
0386     loff_t last_pos = pos + copied;
0387 
0388     /*
0389      * No need to use i_size_read() here, the i_size
0390      * cannot change under us because we hold the i_mutex.
0391      */
0392     if (last_pos > inode->i_size)
0393         i_size_write(inode, last_pos);
0394 
0395     /* zero the stale part of the page if we did a short copy */
0396     if (!PageUptodate(page)) {
0397         unsigned from = pos & (PAGE_SIZE - 1);
0398         if (copied < len) {
0399             zero_user(page, from + copied, len - copied);
0400         }
0401         /* Set fully written pages uptodate. */
0402         if (pos == page_offset(page) &&
0403             (len == PAGE_SIZE || pos + len == inode->i_size)) {
0404             zero_user_segment(page, from + copied, PAGE_SIZE);
0405             SetPageUptodate(page);
0406         }
0407     }
0408 
0409     set_page_dirty(page);
0410     unlock_page(page);
0411     put_page(page);
0412 
0413     mark_inode_dirty_sync(file_inode(file));
0414     return copied;
0415 }
0416 
0417 static void orangefs_invalidate_folio(struct folio *folio,
0418                  size_t offset, size_t length)
0419 {
0420     struct orangefs_write_range *wr = folio_get_private(folio);
0421 
0422     if (offset == 0 && length == PAGE_SIZE) {
0423         kfree(folio_detach_private(folio));
0424         return;
0425     /* write range entirely within invalidate range (or equal) */
0426     } else if (folio_pos(folio) + offset <= wr->pos &&
0427         wr->pos + wr->len <= folio_pos(folio) + offset + length) {
0428         kfree(folio_detach_private(folio));
0429         /* XXX is this right? only caller in fs */
0430         folio_cancel_dirty(folio);
0431         return;
0432     /* invalidate range chops off end of write range */
0433     } else if (wr->pos < folio_pos(folio) + offset &&
0434         wr->pos + wr->len <= folio_pos(folio) + offset + length &&
0435          folio_pos(folio) + offset < wr->pos + wr->len) {
0436         size_t x;
0437         x = wr->pos + wr->len - (folio_pos(folio) + offset);
0438         WARN_ON(x > wr->len);
0439         wr->len -= x;
0440         wr->uid = current_fsuid();
0441         wr->gid = current_fsgid();
0442     /* invalidate range chops off beginning of write range */
0443     } else if (folio_pos(folio) + offset <= wr->pos &&
0444         folio_pos(folio) + offset + length < wr->pos + wr->len &&
0445         wr->pos < folio_pos(folio) + offset + length) {
0446         size_t x;
0447         x = folio_pos(folio) + offset + length - wr->pos;
0448         WARN_ON(x > wr->len);
0449         wr->pos += x;
0450         wr->len -= x;
0451         wr->uid = current_fsuid();
0452         wr->gid = current_fsgid();
0453     /* invalidate range entirely within write range (punch hole) */
0454     } else if (wr->pos < folio_pos(folio) + offset &&
0455         folio_pos(folio) + offset + length < wr->pos + wr->len) {
0456         /* XXX what do we do here... should not WARN_ON */
0457         WARN_ON(1);
0458         /* punch hole */
0459         /*
0460          * should we just ignore this and write it out anyway?
0461          * it hardly makes sense
0462          */
0463         return;
0464     /* non-overlapping ranges */
0465     } else {
0466         /* WARN if they do overlap */
0467         if (!((folio_pos(folio) + offset + length <= wr->pos) ^
0468             (wr->pos + wr->len <= folio_pos(folio) + offset))) {
0469             WARN_ON(1);
0470             printk("invalidate range offset %llu length %zu\n",
0471                 folio_pos(folio) + offset, length);
0472             printk("write range offset %llu length %zu\n",
0473                 wr->pos, wr->len);
0474         }
0475         return;
0476     }
0477 
0478     /*
0479      * Above there are returns where wr is freed or where we WARN.
0480      * Thus the following runs if wr was modified above.
0481      */
0482 
0483     orangefs_launder_folio(folio);
0484 }
0485 
0486 static bool orangefs_release_folio(struct folio *folio, gfp_t foo)
0487 {
0488     return !folio_test_private(folio);
0489 }
0490 
0491 static void orangefs_free_folio(struct folio *folio)
0492 {
0493     kfree(folio_detach_private(folio));
0494 }
0495 
0496 static int orangefs_launder_folio(struct folio *folio)
0497 {
0498     int r = 0;
0499     struct writeback_control wbc = {
0500         .sync_mode = WB_SYNC_ALL,
0501         .nr_to_write = 0,
0502     };
0503     folio_wait_writeback(folio);
0504     if (folio_clear_dirty_for_io(folio)) {
0505         r = orangefs_writepage_locked(&folio->page, &wbc);
0506         folio_end_writeback(folio);
0507     }
0508     return r;
0509 }
0510 
0511 static ssize_t orangefs_direct_IO(struct kiocb *iocb,
0512                   struct iov_iter *iter)
0513 {
0514     /*
0515      * Comment from original do_readv_writev:
0516      * Common entry point for read/write/readv/writev
0517      * This function will dispatch it to either the direct I/O
0518      * or buffered I/O path depending on the mount options and/or
0519      * augmented/extended metadata attached to the file.
0520      * Note: File extended attributes override any mount options.
0521      */
0522     struct file *file = iocb->ki_filp;
0523     loff_t pos = iocb->ki_pos;
0524     enum ORANGEFS_io_type type = iov_iter_rw(iter) == WRITE ?
0525             ORANGEFS_IO_WRITE : ORANGEFS_IO_READ;
0526     loff_t *offset = &pos;
0527     struct inode *inode = file->f_mapping->host;
0528     struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
0529     struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
0530     size_t count = iov_iter_count(iter);
0531     ssize_t total_count = 0;
0532     ssize_t ret = -EINVAL;
0533     int i = 0;
0534 
0535     gossip_debug(GOSSIP_FILE_DEBUG,
0536         "%s-BEGIN(%pU): count(%d) after estimate_max_iovecs.\n",
0537         __func__,
0538         handle,
0539         (int)count);
0540 
0541     if (type == ORANGEFS_IO_WRITE) {
0542         gossip_debug(GOSSIP_FILE_DEBUG,
0543                  "%s(%pU): proceeding with offset : %llu, "
0544                  "size %d\n",
0545                  __func__,
0546                  handle,
0547                  llu(*offset),
0548                  (int)count);
0549     }
0550 
0551     if (count == 0) {
0552         ret = 0;
0553         goto out;
0554     }
0555 
0556     while (iov_iter_count(iter)) {
0557         size_t each_count = iov_iter_count(iter);
0558         size_t amt_complete;
0559         i++;
0560 
0561         /* how much to transfer in this loop iteration */
0562         if (each_count > orangefs_bufmap_size_query())
0563             each_count = orangefs_bufmap_size_query();
0564 
0565         gossip_debug(GOSSIP_FILE_DEBUG,
0566                  "%s(%pU): size of each_count(%d)\n",
0567                  __func__,
0568                  handle,
0569                  (int)each_count);
0570         gossip_debug(GOSSIP_FILE_DEBUG,
0571                  "%s(%pU): BEFORE wait_for_io: offset is %d\n",
0572                  __func__,
0573                  handle,
0574                  (int)*offset);
0575 
0576         ret = wait_for_direct_io(type, inode, offset, iter,
0577                 each_count, 0, NULL, NULL, file);
0578         gossip_debug(GOSSIP_FILE_DEBUG,
0579                  "%s(%pU): return from wait_for_io:%d\n",
0580                  __func__,
0581                  handle,
0582                  (int)ret);
0583 
0584         if (ret < 0)
0585             goto out;
0586 
0587         *offset += ret;
0588         total_count += ret;
0589         amt_complete = ret;
0590 
0591         gossip_debug(GOSSIP_FILE_DEBUG,
0592                  "%s(%pU): AFTER wait_for_io: offset is %d\n",
0593                  __func__,
0594                  handle,
0595                  (int)*offset);
0596 
0597         /*
0598          * if we got a short I/O operations,
0599          * fall out and return what we got so far
0600          */
0601         if (amt_complete < each_count)
0602             break;
0603     } /*end while */
0604 
0605 out:
0606     if (total_count > 0)
0607         ret = total_count;
0608     if (ret > 0) {
0609         if (type == ORANGEFS_IO_READ) {
0610             file_accessed(file);
0611         } else {
0612             file_update_time(file);
0613             if (*offset > i_size_read(inode))
0614                 i_size_write(inode, *offset);
0615         }
0616     }
0617 
0618     gossip_debug(GOSSIP_FILE_DEBUG,
0619              "%s(%pU): Value(%d) returned.\n",
0620              __func__,
0621              handle,
0622              (int)ret);
0623 
0624     return ret;
0625 }
0626 
0627 /** ORANGEFS2 implementation of address space operations */
0628 static const struct address_space_operations orangefs_address_operations = {
0629     .writepage = orangefs_writepage,
0630     .readahead = orangefs_readahead,
0631     .read_folio = orangefs_read_folio,
0632     .writepages = orangefs_writepages,
0633     .dirty_folio = filemap_dirty_folio,
0634     .write_begin = orangefs_write_begin,
0635     .write_end = orangefs_write_end,
0636     .invalidate_folio = orangefs_invalidate_folio,
0637     .release_folio = orangefs_release_folio,
0638     .free_folio = orangefs_free_folio,
0639     .launder_folio = orangefs_launder_folio,
0640     .direct_IO = orangefs_direct_IO,
0641 };
0642 
0643 vm_fault_t orangefs_page_mkwrite(struct vm_fault *vmf)
0644 {
0645     struct folio *folio = page_folio(vmf->page);
0646     struct inode *inode = file_inode(vmf->vma->vm_file);
0647     struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
0648     unsigned long *bitlock = &orangefs_inode->bitlock;
0649     vm_fault_t ret;
0650     struct orangefs_write_range *wr;
0651 
0652     sb_start_pagefault(inode->i_sb);
0653 
0654     if (wait_on_bit(bitlock, 1, TASK_KILLABLE)) {
0655         ret = VM_FAULT_RETRY;
0656         goto out;
0657     }
0658 
0659     folio_lock(folio);
0660     if (folio_test_dirty(folio) && !folio_test_private(folio)) {
0661         /*
0662          * Should be impossible.  If it happens, launder the folio
0663          * since we don't know what's dirty.  This will WARN in
0664          * orangefs_writepage_locked.
0665          */
0666         if (orangefs_launder_folio(folio)) {
0667             ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
0668             goto out;
0669         }
0670     }
0671     if (folio_test_private(folio)) {
0672         wr = folio_get_private(folio);
0673         if (uid_eq(wr->uid, current_fsuid()) &&
0674             gid_eq(wr->gid, current_fsgid())) {
0675             wr->pos = page_offset(vmf->page);
0676             wr->len = PAGE_SIZE;
0677             goto okay;
0678         } else {
0679             if (orangefs_launder_folio(folio)) {
0680                 ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
0681                 goto out;
0682             }
0683         }
0684     }
0685     wr = kmalloc(sizeof *wr, GFP_KERNEL);
0686     if (!wr) {
0687         ret = VM_FAULT_LOCKED|VM_FAULT_RETRY;
0688         goto out;
0689     }
0690     wr->pos = page_offset(vmf->page);
0691     wr->len = PAGE_SIZE;
0692     wr->uid = current_fsuid();
0693     wr->gid = current_fsgid();
0694     folio_attach_private(folio, wr);
0695 okay:
0696 
0697     file_update_time(vmf->vma->vm_file);
0698     if (folio->mapping != inode->i_mapping) {
0699         folio_unlock(folio);
0700         ret = VM_FAULT_LOCKED|VM_FAULT_NOPAGE;
0701         goto out;
0702     }
0703 
0704     /*
0705      * We mark the folio dirty already here so that when freeze is in
0706      * progress, we are guaranteed that writeback during freezing will
0707      * see the dirty folio and writeprotect it again.
0708      */
0709     folio_mark_dirty(folio);
0710     folio_wait_stable(folio);
0711     ret = VM_FAULT_LOCKED;
0712 out:
0713     sb_end_pagefault(inode->i_sb);
0714     return ret;
0715 }
0716 
0717 static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
0718 {
0719     struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
0720     struct orangefs_kernel_op_s *new_op;
0721     loff_t orig_size;
0722     int ret = -EINVAL;
0723 
0724     gossip_debug(GOSSIP_INODE_DEBUG,
0725              "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
0726              __func__,
0727              get_khandle_from_ino(inode),
0728              &orangefs_inode->refn.khandle,
0729              orangefs_inode->refn.fs_id,
0730              iattr->ia_size);
0731 
0732     /* Ensure that we have a up to date size, so we know if it changed. */
0733     ret = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_SIZE);
0734     if (ret == -ESTALE)
0735         ret = -EIO;
0736     if (ret) {
0737         gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
0738             __func__, ret);
0739         return ret;
0740     }
0741     orig_size = i_size_read(inode);
0742 
0743     /* This is truncate_setsize in a different order. */
0744     truncate_pagecache(inode, iattr->ia_size);
0745     i_size_write(inode, iattr->ia_size);
0746     if (iattr->ia_size > orig_size)
0747         pagecache_isize_extended(inode, orig_size, iattr->ia_size);
0748 
0749     new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
0750     if (!new_op)
0751         return -ENOMEM;
0752 
0753     new_op->upcall.req.truncate.refn = orangefs_inode->refn;
0754     new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
0755 
0756     ret = service_operation(new_op,
0757         __func__,
0758         get_interruptible_flag(inode));
0759 
0760     /*
0761      * the truncate has no downcall members to retrieve, but
0762      * the status value tells us if it went through ok or not
0763      */
0764     gossip_debug(GOSSIP_INODE_DEBUG, "%s: ret:%d:\n", __func__, ret);
0765 
0766     op_release(new_op);
0767 
0768     if (ret != 0)
0769         return ret;
0770 
0771     if (orig_size != i_size_read(inode))
0772         iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
0773 
0774     return ret;
0775 }
0776 
0777 int __orangefs_setattr(struct inode *inode, struct iattr *iattr)
0778 {
0779     int ret;
0780 
0781     if (iattr->ia_valid & ATTR_MODE) {
0782         if (iattr->ia_mode & (S_ISVTX)) {
0783             if (is_root_handle(inode)) {
0784                 /*
0785                  * allow sticky bit to be set on root (since
0786                  * it shows up that way by default anyhow),
0787                  * but don't show it to the server
0788                  */
0789                 iattr->ia_mode -= S_ISVTX;
0790             } else {
0791                 gossip_debug(GOSSIP_UTILS_DEBUG,
0792                          "User attempted to set sticky bit on non-root directory; returning EINVAL.\n");
0793                 ret = -EINVAL;
0794                 goto out;
0795             }
0796         }
0797         if (iattr->ia_mode & (S_ISUID)) {
0798             gossip_debug(GOSSIP_UTILS_DEBUG,
0799                      "Attempting to set setuid bit (not supported); returning EINVAL.\n");
0800             ret = -EINVAL;
0801             goto out;
0802         }
0803     }
0804 
0805     if (iattr->ia_valid & ATTR_SIZE) {
0806         ret = orangefs_setattr_size(inode, iattr);
0807         if (ret)
0808             goto out;
0809     }
0810 
0811 again:
0812     spin_lock(&inode->i_lock);
0813     if (ORANGEFS_I(inode)->attr_valid) {
0814         if (uid_eq(ORANGEFS_I(inode)->attr_uid, current_fsuid()) &&
0815             gid_eq(ORANGEFS_I(inode)->attr_gid, current_fsgid())) {
0816             ORANGEFS_I(inode)->attr_valid = iattr->ia_valid;
0817         } else {
0818             spin_unlock(&inode->i_lock);
0819             write_inode_now(inode, 1);
0820             goto again;
0821         }
0822     } else {
0823         ORANGEFS_I(inode)->attr_valid = iattr->ia_valid;
0824         ORANGEFS_I(inode)->attr_uid = current_fsuid();
0825         ORANGEFS_I(inode)->attr_gid = current_fsgid();
0826     }
0827     setattr_copy(&init_user_ns, inode, iattr);
0828     spin_unlock(&inode->i_lock);
0829     mark_inode_dirty(inode);
0830 
0831     if (iattr->ia_valid & ATTR_MODE)
0832         /* change mod on a file that has ACLs */
0833         ret = posix_acl_chmod(&init_user_ns, inode, inode->i_mode);
0834 
0835     ret = 0;
0836 out:
0837     return ret;
0838 }
0839 
0840 /*
0841  * Change attributes of an object referenced by dentry.
0842  */
0843 int orangefs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
0844              struct iattr *iattr)
0845 {
0846     int ret;
0847     gossip_debug(GOSSIP_INODE_DEBUG, "__orangefs_setattr: called on %pd\n",
0848         dentry);
0849     ret = setattr_prepare(&init_user_ns, dentry, iattr);
0850     if (ret)
0851             goto out;
0852     ret = __orangefs_setattr(d_inode(dentry), iattr);
0853     sync_inode_metadata(d_inode(dentry), 1);
0854 out:
0855     gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n",
0856         ret);
0857     return ret;
0858 }
0859 
0860 /*
0861  * Obtain attributes of an object given a dentry
0862  */
0863 int orangefs_getattr(struct user_namespace *mnt_userns, const struct path *path,
0864              struct kstat *stat, u32 request_mask, unsigned int flags)
0865 {
0866     int ret;
0867     struct inode *inode = path->dentry->d_inode;
0868 
0869     gossip_debug(GOSSIP_INODE_DEBUG,
0870              "orangefs_getattr: called on %pd mask %u\n",
0871              path->dentry, request_mask);
0872 
0873     ret = orangefs_inode_getattr(inode,
0874         request_mask & STATX_SIZE ? ORANGEFS_GETATTR_SIZE : 0);
0875     if (ret == 0) {
0876         generic_fillattr(&init_user_ns, inode, stat);
0877 
0878         /* override block size reported to stat */
0879         if (!(request_mask & STATX_SIZE))
0880             stat->result_mask &= ~STATX_SIZE;
0881 
0882         generic_fill_statx_attr(inode, stat);
0883     }
0884     return ret;
0885 }
0886 
0887 int orangefs_permission(struct user_namespace *mnt_userns,
0888             struct inode *inode, int mask)
0889 {
0890     int ret;
0891 
0892     if (mask & MAY_NOT_BLOCK)
0893         return -ECHILD;
0894 
0895     gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
0896 
0897     /* Make sure the permission (and other common attrs) are up to date. */
0898     ret = orangefs_inode_getattr(inode, 0);
0899     if (ret < 0)
0900         return ret;
0901 
0902     return generic_permission(&init_user_ns, inode, mask);
0903 }
0904 
0905 int orangefs_update_time(struct inode *inode, struct timespec64 *time, int flags)
0906 {
0907     struct iattr iattr;
0908     gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_update_time: %pU\n",
0909         get_khandle_from_ino(inode));
0910     generic_update_time(inode, time, flags);
0911     memset(&iattr, 0, sizeof iattr);
0912         if (flags & S_ATIME)
0913         iattr.ia_valid |= ATTR_ATIME;
0914     if (flags & S_CTIME)
0915         iattr.ia_valid |= ATTR_CTIME;
0916     if (flags & S_MTIME)
0917         iattr.ia_valid |= ATTR_MTIME;
0918     return __orangefs_setattr(inode, &iattr);
0919 }
0920 
0921 static int orangefs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
0922 {
0923     u64 val = 0;
0924     int ret;
0925 
0926     gossip_debug(GOSSIP_FILE_DEBUG, "%s: called on %pd\n", __func__,
0927              dentry);
0928 
0929     ret = orangefs_inode_getxattr(d_inode(dentry),
0930                       "user.pvfs2.meta_hint",
0931                       &val, sizeof(val));
0932     if (ret < 0 && ret != -ENODATA)
0933         return ret;
0934 
0935     gossip_debug(GOSSIP_FILE_DEBUG, "%s: flags=%u\n", __func__, (u32) val);
0936 
0937     fileattr_fill_flags(fa, val);
0938     return 0;
0939 }
0940 
0941 static int orangefs_fileattr_set(struct user_namespace *mnt_userns,
0942                  struct dentry *dentry, struct fileattr *fa)
0943 {
0944     u64 val = 0;
0945 
0946     gossip_debug(GOSSIP_FILE_DEBUG, "%s: called on %pd\n", __func__,
0947              dentry);
0948     /*
0949      * ORANGEFS_MIRROR_FL is set internally when the mirroring mode is
0950      * turned on for a file. The user is not allowed to turn on this bit,
0951      * but the bit is present if the user first gets the flags and then
0952      * updates the flags with some new settings. So, we ignore it in the
0953      * following edit. bligon.
0954      */
0955     if (fileattr_has_fsx(fa) ||
0956         (fa->flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL | ORANGEFS_MIRROR_FL))) {
0957         gossip_err("%s: only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n",
0958                __func__);
0959         return -EOPNOTSUPP;
0960     }
0961     val = fa->flags;
0962     gossip_debug(GOSSIP_FILE_DEBUG, "%s: flags=%u\n", __func__, (u32) val);
0963     return orangefs_inode_setxattr(d_inode(dentry),
0964                        "user.pvfs2.meta_hint",
0965                        &val, sizeof(val), 0);
0966 }
0967 
0968 /* ORANGEFS2 implementation of VFS inode operations for files */
0969 static const struct inode_operations orangefs_file_inode_operations = {
0970     .get_acl = orangefs_get_acl,
0971     .set_acl = orangefs_set_acl,
0972     .setattr = orangefs_setattr,
0973     .getattr = orangefs_getattr,
0974     .listxattr = orangefs_listxattr,
0975     .permission = orangefs_permission,
0976     .update_time = orangefs_update_time,
0977     .fileattr_get = orangefs_fileattr_get,
0978     .fileattr_set = orangefs_fileattr_set,
0979 };
0980 
0981 static int orangefs_init_iops(struct inode *inode)
0982 {
0983     inode->i_mapping->a_ops = &orangefs_address_operations;
0984 
0985     switch (inode->i_mode & S_IFMT) {
0986     case S_IFREG:
0987         inode->i_op = &orangefs_file_inode_operations;
0988         inode->i_fop = &orangefs_file_operations;
0989         break;
0990     case S_IFLNK:
0991         inode->i_op = &orangefs_symlink_inode_operations;
0992         break;
0993     case S_IFDIR:
0994         inode->i_op = &orangefs_dir_inode_operations;
0995         inode->i_fop = &orangefs_dir_operations;
0996         break;
0997     default:
0998         gossip_debug(GOSSIP_INODE_DEBUG,
0999                  "%s: unsupported mode\n",
1000                  __func__);
1001         return -EINVAL;
1002     }
1003 
1004     return 0;
1005 }
1006 
1007 /*
1008  * Given an ORANGEFS object identifier (fsid, handle), convert it into
1009  * a ino_t type that will be used as a hash-index from where the handle will
1010  * be searched for in the VFS hash table of inodes.
1011  */
1012 static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
1013 {
1014     if (!ref)
1015         return 0;
1016     return orangefs_khandle_to_ino(&(ref->khandle));
1017 }
1018 
1019 /*
1020  * Called to set up an inode from iget5_locked.
1021  */
1022 static int orangefs_set_inode(struct inode *inode, void *data)
1023 {
1024     struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
1025     ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
1026     ORANGEFS_I(inode)->refn.khandle = ref->khandle;
1027     ORANGEFS_I(inode)->attr_valid = 0;
1028     hash_init(ORANGEFS_I(inode)->xattr_cache);
1029     ORANGEFS_I(inode)->mapping_time = jiffies - 1;
1030     ORANGEFS_I(inode)->bitlock = 0;
1031     return 0;
1032 }
1033 
1034 /*
1035  * Called to determine if handles match.
1036  */
1037 static int orangefs_test_inode(struct inode *inode, void *data)
1038 {
1039     struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
1040     struct orangefs_inode_s *orangefs_inode = NULL;
1041 
1042     orangefs_inode = ORANGEFS_I(inode);
1043     /* test handles and fs_ids... */
1044     return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle),
1045                 &(ref->khandle)) &&
1046             orangefs_inode->refn.fs_id == ref->fs_id);
1047 }
1048 
1049 /*
1050  * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
1051  * file handle.
1052  *
1053  * @sb: the file system super block instance.
1054  * @ref: The ORANGEFS object for which we are trying to locate an inode.
1055  */
1056 struct inode *orangefs_iget(struct super_block *sb,
1057         struct orangefs_object_kref *ref)
1058 {
1059     struct inode *inode = NULL;
1060     unsigned long hash;
1061     int error;
1062 
1063     hash = orangefs_handle_hash(ref);
1064     inode = iget5_locked(sb,
1065             hash,
1066             orangefs_test_inode,
1067             orangefs_set_inode,
1068             ref);
1069 
1070     if (!inode)
1071         return ERR_PTR(-ENOMEM);
1072 
1073     if (!(inode->i_state & I_NEW))
1074         return inode;
1075 
1076     error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW);
1077     if (error) {
1078         iget_failed(inode);
1079         return ERR_PTR(error);
1080     }
1081 
1082     inode->i_ino = hash;    /* needed for stat etc */
1083     orangefs_init_iops(inode);
1084     unlock_new_inode(inode);
1085 
1086     gossip_debug(GOSSIP_INODE_DEBUG,
1087              "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
1088              &ref->khandle,
1089              ref->fs_id,
1090              hash,
1091              inode->i_ino);
1092 
1093     return inode;
1094 }
1095 
1096 /*
1097  * Allocate an inode for a newly created file and insert it into the inode hash.
1098  */
1099 struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
1100         int mode, dev_t dev, struct orangefs_object_kref *ref)
1101 {
1102     unsigned long hash = orangefs_handle_hash(ref);
1103     struct inode *inode;
1104     int error;
1105 
1106     gossip_debug(GOSSIP_INODE_DEBUG,
1107              "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
1108              __func__,
1109              sb,
1110              MAJOR(dev),
1111              MINOR(dev),
1112              mode);
1113 
1114     inode = new_inode(sb);
1115     if (!inode)
1116         return ERR_PTR(-ENOMEM);
1117 
1118     orangefs_set_inode(inode, ref);
1119     inode->i_ino = hash;    /* needed for stat etc */
1120 
1121     error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW);
1122     if (error)
1123         goto out_iput;
1124 
1125     orangefs_init_iops(inode);
1126     inode->i_rdev = dev;
1127 
1128     error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
1129     if (error < 0)
1130         goto out_iput;
1131 
1132     gossip_debug(GOSSIP_INODE_DEBUG,
1133              "Initializing ACL's for inode %pU\n",
1134              get_khandle_from_ino(inode));
1135     orangefs_init_acl(inode, dir);
1136     return inode;
1137 
1138 out_iput:
1139     iput(inode);
1140     return ERR_PTR(error);
1141 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!