Loading...
1/*
2 * (C) 2001 Clemson University and The University of Chicago
3 *
4 * See COPYING in top-level directory.
5 */
6
7/*
8 * Linux VFS inode operations.
9 */
10
11#include "protocol.h"
12#include "orangefs-kernel.h"
13#include "orangefs-bufmap.h"
14
15static int read_one_page(struct page *page)
16{
17 int ret;
18 int max_block;
19 ssize_t bytes_read = 0;
20 struct inode *inode = page->mapping->host;
21 const __u32 blocksize = PAGE_SIZE; /* inode->i_blksize */
22 const __u32 blockbits = PAGE_SHIFT; /* inode->i_blkbits */
23 struct iov_iter to;
24 struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
25
26 iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
27
28 gossip_debug(GOSSIP_INODE_DEBUG,
29 "orangefs_readpage called with page %p\n",
30 page);
31
32 max_block = ((inode->i_size / blocksize) + 1);
33
34 if (page->index < max_block) {
35 loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
36
37 bytes_read = orangefs_inode_read(inode,
38 &to,
39 &blockptr_offset,
40 inode->i_size);
41 }
42 /* this will only zero remaining unread portions of the page data */
43 iov_iter_zero(~0U, &to);
44 /* takes care of potential aliasing */
45 flush_dcache_page(page);
46 if (bytes_read < 0) {
47 ret = bytes_read;
48 SetPageError(page);
49 } else {
50 SetPageUptodate(page);
51 if (PageError(page))
52 ClearPageError(page);
53 ret = 0;
54 }
55 /* unlock the page after the ->readpage() routine completes */
56 unlock_page(page);
57 return ret;
58}
59
60static int orangefs_readpage(struct file *file, struct page *page)
61{
62 return read_one_page(page);
63}
64
65static int orangefs_readpages(struct file *file,
66 struct address_space *mapping,
67 struct list_head *pages,
68 unsigned nr_pages)
69{
70 int page_idx;
71 int ret;
72
73 gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
74
75 for (page_idx = 0; page_idx < nr_pages; page_idx++) {
76 struct page *page;
77
78 page = list_entry(pages->prev, struct page, lru);
79 list_del(&page->lru);
80 if (!add_to_page_cache(page,
81 mapping,
82 page->index,
83 GFP_KERNEL)) {
84 ret = read_one_page(page);
85 gossip_debug(GOSSIP_INODE_DEBUG,
86 "failure adding page to cache, read_one_page returned: %d\n",
87 ret);
88 } else {
89 put_page(page);
90 }
91 }
92 BUG_ON(!list_empty(pages));
93 return 0;
94}
95
96static void orangefs_invalidatepage(struct page *page,
97 unsigned int offset,
98 unsigned int length)
99{
100 gossip_debug(GOSSIP_INODE_DEBUG,
101 "orangefs_invalidatepage called on page %p "
102 "(offset is %u)\n",
103 page,
104 offset);
105
106 ClearPageUptodate(page);
107 ClearPageMappedToDisk(page);
108 return;
109
110}
111
112static int orangefs_releasepage(struct page *page, gfp_t foo)
113{
114 gossip_debug(GOSSIP_INODE_DEBUG,
115 "orangefs_releasepage called on page %p\n",
116 page);
117 return 0;
118}
119
120/*
121 * Having a direct_IO entry point in the address_space_operations
122 * struct causes the kernel to allows us to use O_DIRECT on
123 * open. Nothing will ever call this thing, but in the future we
124 * will need to be able to use O_DIRECT on open in order to support
125 * AIO. Modeled after NFS, they do this too.
126 */
127/*
128 * static ssize_t orangefs_direct_IO(int rw,
129 * struct kiocb *iocb,
130 * struct iov_iter *iter,
131 * loff_t offset)
132 *{
133 * gossip_debug(GOSSIP_INODE_DEBUG,
134 * "orangefs_direct_IO: %s\n",
135 * iocb->ki_filp->f_path.dentry->d_name.name);
136 *
137 * return -EINVAL;
138 *}
139 */
140
141struct backing_dev_info orangefs_backing_dev_info = {
142 .name = "orangefs",
143 .ra_pages = 0,
144 .capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
145};
146
147/** ORANGEFS2 implementation of address space operations */
148const struct address_space_operations orangefs_address_operations = {
149 .readpage = orangefs_readpage,
150 .readpages = orangefs_readpages,
151 .invalidatepage = orangefs_invalidatepage,
152 .releasepage = orangefs_releasepage,
153/* .direct_IO = orangefs_direct_IO */
154};
155
156static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
157{
158 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
159 struct orangefs_kernel_op_s *new_op;
160 loff_t orig_size;
161 int ret = -EINVAL;
162
163 gossip_debug(GOSSIP_INODE_DEBUG,
164 "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
165 __func__,
166 get_khandle_from_ino(inode),
167 &orangefs_inode->refn.khandle,
168 orangefs_inode->refn.fs_id,
169 iattr->ia_size);
170
171 /* Ensure that we have a up to date size, so we know if it changed. */
172 ret = orangefs_inode_getattr(inode, 0, 1);
173 if (ret == -ESTALE)
174 ret = -EIO;
175 if (ret) {
176 gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
177 __func__, ret);
178 return ret;
179 }
180 orig_size = i_size_read(inode);
181
182 truncate_setsize(inode, iattr->ia_size);
183
184 new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
185 if (!new_op)
186 return -ENOMEM;
187
188 new_op->upcall.req.truncate.refn = orangefs_inode->refn;
189 new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
190
191 ret = service_operation(new_op, __func__,
192 get_interruptible_flag(inode));
193
194 /*
195 * the truncate has no downcall members to retrieve, but
196 * the status value tells us if it went through ok or not
197 */
198 gossip_debug(GOSSIP_INODE_DEBUG,
199 "orangefs: orangefs_truncate got return value of %d\n",
200 ret);
201
202 op_release(new_op);
203
204 if (ret != 0)
205 return ret;
206
207 if (orig_size != i_size_read(inode))
208 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
209
210 return ret;
211}
212
213/*
214 * Change attributes of an object referenced by dentry.
215 */
216int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
217{
218 int ret = -EINVAL;
219 struct inode *inode = dentry->d_inode;
220
221 gossip_debug(GOSSIP_INODE_DEBUG,
222 "orangefs_setattr: called on %s\n",
223 dentry->d_name.name);
224
225 ret = inode_change_ok(inode, iattr);
226 if (ret)
227 goto out;
228
229 if ((iattr->ia_valid & ATTR_SIZE) &&
230 iattr->ia_size != i_size_read(inode)) {
231 ret = orangefs_setattr_size(inode, iattr);
232 if (ret)
233 goto out;
234 }
235
236 setattr_copy(inode, iattr);
237 mark_inode_dirty(inode);
238
239 ret = orangefs_inode_setattr(inode, iattr);
240 gossip_debug(GOSSIP_INODE_DEBUG,
241 "orangefs_setattr: inode_setattr returned %d\n",
242 ret);
243
244 if (!ret && (iattr->ia_valid & ATTR_MODE))
245 /* change mod on a file that has ACLs */
246 ret = posix_acl_chmod(inode, inode->i_mode);
247
248out:
249 gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
250 return ret;
251}
252
253/*
254 * Obtain attributes of an object given a dentry
255 */
256int orangefs_getattr(struct vfsmount *mnt,
257 struct dentry *dentry,
258 struct kstat *kstat)
259{
260 int ret = -ENOENT;
261 struct inode *inode = dentry->d_inode;
262 struct orangefs_inode_s *orangefs_inode = NULL;
263
264 gossip_debug(GOSSIP_INODE_DEBUG,
265 "orangefs_getattr: called on %s\n",
266 dentry->d_name.name);
267
268 ret = orangefs_inode_getattr(inode, 0, 1);
269 if (ret == 0) {
270 generic_fillattr(inode, kstat);
271
272 /* override block size reported to stat */
273 orangefs_inode = ORANGEFS_I(inode);
274 kstat->blksize = orangefs_inode->blksize;
275 }
276 return ret;
277}
278
279int orangefs_permission(struct inode *inode, int mask)
280{
281 int ret;
282
283 if (mask & MAY_NOT_BLOCK)
284 return -ECHILD;
285
286 gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
287
288 /* Make sure the permission (and other common attrs) are up to date. */
289 ret = orangefs_inode_getattr(inode, 0, 0);
290 if (ret < 0)
291 return ret;
292
293 return generic_permission(inode, mask);
294}
295
296/* ORANGEDS2 implementation of VFS inode operations for files */
297struct inode_operations orangefs_file_inode_operations = {
298 .get_acl = orangefs_get_acl,
299 .set_acl = orangefs_set_acl,
300 .setattr = orangefs_setattr,
301 .getattr = orangefs_getattr,
302 .setxattr = generic_setxattr,
303 .getxattr = generic_getxattr,
304 .listxattr = orangefs_listxattr,
305 .removexattr = generic_removexattr,
306 .permission = orangefs_permission,
307};
308
309static int orangefs_init_iops(struct inode *inode)
310{
311 inode->i_mapping->a_ops = &orangefs_address_operations;
312
313 switch (inode->i_mode & S_IFMT) {
314 case S_IFREG:
315 inode->i_op = &orangefs_file_inode_operations;
316 inode->i_fop = &orangefs_file_operations;
317 inode->i_blkbits = PAGE_SHIFT;
318 break;
319 case S_IFLNK:
320 inode->i_op = &orangefs_symlink_inode_operations;
321 break;
322 case S_IFDIR:
323 inode->i_op = &orangefs_dir_inode_operations;
324 inode->i_fop = &orangefs_dir_operations;
325 break;
326 default:
327 gossip_debug(GOSSIP_INODE_DEBUG,
328 "%s: unsupported mode\n",
329 __func__);
330 return -EINVAL;
331 }
332
333 return 0;
334}
335
336/*
337 * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
338 * that will be used as a hash-index from where the handle will
339 * be searched for in the VFS hash table of inodes.
340 */
341static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
342{
343 if (!ref)
344 return 0;
345 return orangefs_khandle_to_ino(&(ref->khandle));
346}
347
348/*
349 * Called to set up an inode from iget5_locked.
350 */
351static int orangefs_set_inode(struct inode *inode, void *data)
352{
353 struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
354 ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
355 ORANGEFS_I(inode)->refn.khandle = ref->khandle;
356 return 0;
357}
358
359/*
360 * Called to determine if handles match.
361 */
362static int orangefs_test_inode(struct inode *inode, void *data)
363{
364 struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
365 struct orangefs_inode_s *orangefs_inode = NULL;
366
367 orangefs_inode = ORANGEFS_I(inode);
368 return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
369 && orangefs_inode->refn.fs_id == ref->fs_id);
370}
371
372/*
373 * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
374 * file handle.
375 *
376 * @sb: the file system super block instance.
377 * @ref: The ORANGEFS object for which we are trying to locate an inode structure.
378 */
379struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
380{
381 struct inode *inode = NULL;
382 unsigned long hash;
383 int error;
384
385 hash = orangefs_handle_hash(ref);
386 inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
387 if (!inode || !(inode->i_state & I_NEW))
388 return inode;
389
390 error = orangefs_inode_getattr(inode, 1, 0);
391 if (error) {
392 iget_failed(inode);
393 return ERR_PTR(error);
394 }
395
396 inode->i_ino = hash; /* needed for stat etc */
397 orangefs_init_iops(inode);
398 unlock_new_inode(inode);
399
400 gossip_debug(GOSSIP_INODE_DEBUG,
401 "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
402 &ref->khandle,
403 ref->fs_id,
404 hash,
405 inode->i_ino);
406
407 return inode;
408}
409
410/*
411 * Allocate an inode for a newly created file and insert it into the inode hash.
412 */
413struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
414 int mode, dev_t dev, struct orangefs_object_kref *ref)
415{
416 unsigned long hash = orangefs_handle_hash(ref);
417 struct inode *inode;
418 int error;
419
420 gossip_debug(GOSSIP_INODE_DEBUG,
421 "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
422 __func__,
423 sb,
424 MAJOR(dev),
425 MINOR(dev),
426 mode);
427
428 inode = new_inode(sb);
429 if (!inode)
430 return NULL;
431
432 orangefs_set_inode(inode, ref);
433 inode->i_ino = hash; /* needed for stat etc */
434
435 error = orangefs_inode_getattr(inode, 1, 0);
436 if (error)
437 goto out_iput;
438
439 orangefs_init_iops(inode);
440
441 inode->i_mode = mode;
442 inode->i_uid = current_fsuid();
443 inode->i_gid = current_fsgid();
444 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
445 inode->i_size = PAGE_SIZE;
446 inode->i_rdev = dev;
447
448 error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
449 if (error < 0)
450 goto out_iput;
451
452 gossip_debug(GOSSIP_INODE_DEBUG,
453 "Initializing ACL's for inode %pU\n",
454 get_khandle_from_ino(inode));
455 orangefs_init_acl(inode, dir);
456 return inode;
457
458out_iput:
459 iput(inode);
460 return ERR_PTR(error);
461}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) 2001 Clemson University and The University of Chicago
4 *
5 * See COPYING in top-level directory.
6 */
7
8/*
9 * Linux VFS inode operations.
10 */
11
12#include <linux/bvec.h>
13#include "protocol.h"
14#include "orangefs-kernel.h"
15#include "orangefs-bufmap.h"
16
17static int read_one_page(struct page *page)
18{
19 int ret;
20 int max_block;
21 ssize_t bytes_read = 0;
22 struct inode *inode = page->mapping->host;
23 const __u32 blocksize = PAGE_SIZE; /* inode->i_blksize */
24 const __u32 blockbits = PAGE_SHIFT; /* inode->i_blkbits */
25 struct iov_iter to;
26 struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
27
28 iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
29
30 gossip_debug(GOSSIP_INODE_DEBUG,
31 "orangefs_readpage called with page %p\n",
32 page);
33
34 max_block = ((inode->i_size / blocksize) + 1);
35
36 if (page->index < max_block) {
37 loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
38
39 bytes_read = orangefs_inode_read(inode,
40 &to,
41 &blockptr_offset,
42 inode->i_size);
43 }
44 /* this will only zero remaining unread portions of the page data */
45 iov_iter_zero(~0U, &to);
46 /* takes care of potential aliasing */
47 flush_dcache_page(page);
48 if (bytes_read < 0) {
49 ret = bytes_read;
50 SetPageError(page);
51 } else {
52 SetPageUptodate(page);
53 if (PageError(page))
54 ClearPageError(page);
55 ret = 0;
56 }
57 /* unlock the page after the ->readpage() routine completes */
58 unlock_page(page);
59 return ret;
60}
61
62static int orangefs_readpage(struct file *file, struct page *page)
63{
64 return read_one_page(page);
65}
66
67static int orangefs_readpages(struct file *file,
68 struct address_space *mapping,
69 struct list_head *pages,
70 unsigned nr_pages)
71{
72 int page_idx;
73 int ret;
74
75 gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
76
77 for (page_idx = 0; page_idx < nr_pages; page_idx++) {
78 struct page *page;
79
80 page = list_entry(pages->prev, struct page, lru);
81 list_del(&page->lru);
82 if (!add_to_page_cache(page,
83 mapping,
84 page->index,
85 readahead_gfp_mask(mapping))) {
86 ret = read_one_page(page);
87 gossip_debug(GOSSIP_INODE_DEBUG,
88 "failure adding page to cache, read_one_page returned: %d\n",
89 ret);
90 } else {
91 put_page(page);
92 }
93 }
94 BUG_ON(!list_empty(pages));
95 return 0;
96}
97
98static void orangefs_invalidatepage(struct page *page,
99 unsigned int offset,
100 unsigned int length)
101{
102 gossip_debug(GOSSIP_INODE_DEBUG,
103 "orangefs_invalidatepage called on page %p "
104 "(offset is %u)\n",
105 page,
106 offset);
107
108 ClearPageUptodate(page);
109 ClearPageMappedToDisk(page);
110 return;
111
112}
113
114static int orangefs_releasepage(struct page *page, gfp_t foo)
115{
116 gossip_debug(GOSSIP_INODE_DEBUG,
117 "orangefs_releasepage called on page %p\n",
118 page);
119 return 0;
120}
121
122/*
123 * Having a direct_IO entry point in the address_space_operations
124 * struct causes the kernel to allows us to use O_DIRECT on
125 * open. Nothing will ever call this thing, but in the future we
126 * will need to be able to use O_DIRECT on open in order to support
127 * AIO. Modeled after NFS, they do this too.
128 */
129
130static ssize_t orangefs_direct_IO(struct kiocb *iocb,
131 struct iov_iter *iter)
132{
133 gossip_debug(GOSSIP_INODE_DEBUG,
134 "orangefs_direct_IO: %pD\n",
135 iocb->ki_filp);
136
137 return -EINVAL;
138}
139
140/** ORANGEFS2 implementation of address space operations */
141static const struct address_space_operations orangefs_address_operations = {
142 .readpage = orangefs_readpage,
143 .readpages = orangefs_readpages,
144 .invalidatepage = orangefs_invalidatepage,
145 .releasepage = orangefs_releasepage,
146 .direct_IO = orangefs_direct_IO,
147};
148
149static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
150{
151 struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
152 struct orangefs_kernel_op_s *new_op;
153 loff_t orig_size;
154 int ret = -EINVAL;
155
156 gossip_debug(GOSSIP_INODE_DEBUG,
157 "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
158 __func__,
159 get_khandle_from_ino(inode),
160 &orangefs_inode->refn.khandle,
161 orangefs_inode->refn.fs_id,
162 iattr->ia_size);
163
164 /* Ensure that we have a up to date size, so we know if it changed. */
165 ret = orangefs_inode_getattr(inode, 0, 1, STATX_SIZE);
166 if (ret == -ESTALE)
167 ret = -EIO;
168 if (ret) {
169 gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
170 __func__, ret);
171 return ret;
172 }
173 orig_size = i_size_read(inode);
174
175 truncate_setsize(inode, iattr->ia_size);
176
177 new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
178 if (!new_op)
179 return -ENOMEM;
180
181 new_op->upcall.req.truncate.refn = orangefs_inode->refn;
182 new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
183
184 ret = service_operation(new_op, __func__,
185 get_interruptible_flag(inode));
186
187 /*
188 * the truncate has no downcall members to retrieve, but
189 * the status value tells us if it went through ok or not
190 */
191 gossip_debug(GOSSIP_INODE_DEBUG,
192 "orangefs: orangefs_truncate got return value of %d\n",
193 ret);
194
195 op_release(new_op);
196
197 if (ret != 0)
198 return ret;
199
200 if (orig_size != i_size_read(inode))
201 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
202
203 return ret;
204}
205
206/*
207 * Change attributes of an object referenced by dentry.
208 */
209int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
210{
211 int ret = -EINVAL;
212 struct inode *inode = dentry->d_inode;
213
214 gossip_debug(GOSSIP_INODE_DEBUG,
215 "orangefs_setattr: called on %pd\n",
216 dentry);
217
218 ret = setattr_prepare(dentry, iattr);
219 if (ret)
220 goto out;
221
222 if (iattr->ia_valid & ATTR_SIZE) {
223 ret = orangefs_setattr_size(inode, iattr);
224 if (ret)
225 goto out;
226 }
227
228 setattr_copy(inode, iattr);
229 mark_inode_dirty(inode);
230
231 ret = orangefs_inode_setattr(inode, iattr);
232 gossip_debug(GOSSIP_INODE_DEBUG,
233 "orangefs_setattr: inode_setattr returned %d\n",
234 ret);
235
236 if (!ret && (iattr->ia_valid & ATTR_MODE))
237 /* change mod on a file that has ACLs */
238 ret = posix_acl_chmod(inode, inode->i_mode);
239
240out:
241 gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
242 return ret;
243}
244
245/*
246 * Obtain attributes of an object given a dentry
247 */
248int orangefs_getattr(const struct path *path, struct kstat *stat,
249 u32 request_mask, unsigned int flags)
250{
251 int ret = -ENOENT;
252 struct inode *inode = path->dentry->d_inode;
253 struct orangefs_inode_s *orangefs_inode = NULL;
254
255 gossip_debug(GOSSIP_INODE_DEBUG,
256 "orangefs_getattr: called on %pd\n",
257 path->dentry);
258
259 ret = orangefs_inode_getattr(inode, 0, 0, request_mask);
260 if (ret == 0) {
261 generic_fillattr(inode, stat);
262
263 /* override block size reported to stat */
264 orangefs_inode = ORANGEFS_I(inode);
265 stat->blksize = orangefs_inode->blksize;
266
267 if (request_mask & STATX_SIZE)
268 stat->result_mask = STATX_BASIC_STATS;
269 else
270 stat->result_mask = STATX_BASIC_STATS &
271 ~STATX_SIZE;
272 }
273 return ret;
274}
275
276int orangefs_permission(struct inode *inode, int mask)
277{
278 int ret;
279
280 if (mask & MAY_NOT_BLOCK)
281 return -ECHILD;
282
283 gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
284
285 /* Make sure the permission (and other common attrs) are up to date. */
286 ret = orangefs_inode_getattr(inode, 0, 0, STATX_MODE);
287 if (ret < 0)
288 return ret;
289
290 return generic_permission(inode, mask);
291}
292
293int orangefs_update_time(struct inode *inode, struct timespec *time, int flags)
294{
295 struct iattr iattr;
296 gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_update_time: %pU\n",
297 get_khandle_from_ino(inode));
298 generic_update_time(inode, time, flags);
299 memset(&iattr, 0, sizeof iattr);
300 if (flags & S_ATIME)
301 iattr.ia_valid |= ATTR_ATIME;
302 if (flags & S_CTIME)
303 iattr.ia_valid |= ATTR_CTIME;
304 if (flags & S_MTIME)
305 iattr.ia_valid |= ATTR_MTIME;
306 return orangefs_inode_setattr(inode, &iattr);
307}
308
309/* ORANGEDS2 implementation of VFS inode operations for files */
310static const struct inode_operations orangefs_file_inode_operations = {
311 .get_acl = orangefs_get_acl,
312 .set_acl = orangefs_set_acl,
313 .setattr = orangefs_setattr,
314 .getattr = orangefs_getattr,
315 .listxattr = orangefs_listxattr,
316 .permission = orangefs_permission,
317 .update_time = orangefs_update_time,
318};
319
320static int orangefs_init_iops(struct inode *inode)
321{
322 inode->i_mapping->a_ops = &orangefs_address_operations;
323
324 switch (inode->i_mode & S_IFMT) {
325 case S_IFREG:
326 inode->i_op = &orangefs_file_inode_operations;
327 inode->i_fop = &orangefs_file_operations;
328 inode->i_blkbits = PAGE_SHIFT;
329 break;
330 case S_IFLNK:
331 inode->i_op = &orangefs_symlink_inode_operations;
332 break;
333 case S_IFDIR:
334 inode->i_op = &orangefs_dir_inode_operations;
335 inode->i_fop = &orangefs_dir_operations;
336 break;
337 default:
338 gossip_debug(GOSSIP_INODE_DEBUG,
339 "%s: unsupported mode\n",
340 __func__);
341 return -EINVAL;
342 }
343
344 return 0;
345}
346
347/*
348 * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
349 * that will be used as a hash-index from where the handle will
350 * be searched for in the VFS hash table of inodes.
351 */
352static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
353{
354 if (!ref)
355 return 0;
356 return orangefs_khandle_to_ino(&(ref->khandle));
357}
358
359/*
360 * Called to set up an inode from iget5_locked.
361 */
362static int orangefs_set_inode(struct inode *inode, void *data)
363{
364 struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
365 ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
366 ORANGEFS_I(inode)->refn.khandle = ref->khandle;
367 return 0;
368}
369
370/*
371 * Called to determine if handles match.
372 */
373static int orangefs_test_inode(struct inode *inode, void *data)
374{
375 struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
376 struct orangefs_inode_s *orangefs_inode = NULL;
377
378 orangefs_inode = ORANGEFS_I(inode);
379 return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
380 && orangefs_inode->refn.fs_id == ref->fs_id);
381}
382
383/*
384 * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
385 * file handle.
386 *
387 * @sb: the file system super block instance.
388 * @ref: The ORANGEFS object for which we are trying to locate an inode structure.
389 */
390struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
391{
392 struct inode *inode = NULL;
393 unsigned long hash;
394 int error;
395
396 hash = orangefs_handle_hash(ref);
397 inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
398 if (!inode || !(inode->i_state & I_NEW))
399 return inode;
400
401 error = orangefs_inode_getattr(inode, 1, 1, STATX_ALL);
402 if (error) {
403 iget_failed(inode);
404 return ERR_PTR(error);
405 }
406
407 inode->i_ino = hash; /* needed for stat etc */
408 orangefs_init_iops(inode);
409 unlock_new_inode(inode);
410
411 gossip_debug(GOSSIP_INODE_DEBUG,
412 "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
413 &ref->khandle,
414 ref->fs_id,
415 hash,
416 inode->i_ino);
417
418 return inode;
419}
420
421/*
422 * Allocate an inode for a newly created file and insert it into the inode hash.
423 */
424struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
425 int mode, dev_t dev, struct orangefs_object_kref *ref)
426{
427 unsigned long hash = orangefs_handle_hash(ref);
428 struct inode *inode;
429 int error;
430
431 gossip_debug(GOSSIP_INODE_DEBUG,
432 "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
433 __func__,
434 sb,
435 MAJOR(dev),
436 MINOR(dev),
437 mode);
438
439 inode = new_inode(sb);
440 if (!inode)
441 return NULL;
442
443 orangefs_set_inode(inode, ref);
444 inode->i_ino = hash; /* needed for stat etc */
445
446 error = orangefs_inode_getattr(inode, 1, 1, STATX_ALL);
447 if (error)
448 goto out_iput;
449
450 orangefs_init_iops(inode);
451
452 inode->i_mode = mode;
453 inode->i_uid = current_fsuid();
454 inode->i_gid = current_fsgid();
455 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
456 inode->i_size = PAGE_SIZE;
457 inode->i_rdev = dev;
458
459 error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
460 if (error < 0)
461 goto out_iput;
462
463 gossip_debug(GOSSIP_INODE_DEBUG,
464 "Initializing ACL's for inode %pU\n",
465 get_khandle_from_ino(inode));
466 orangefs_init_acl(inode, dir);
467 return inode;
468
469out_iput:
470 iput(inode);
471 return ERR_PTR(error);
472}