xattr.c 27 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060
  1. /*
  2. * linux/fs/reiserfs/xattr.c
  3. *
  4. * Copyright (c) 2002 by Jeff Mahoney, <jeffm@suse.com>
  5. *
  6. */
  7. /*
  8. * In order to implement EA/ACLs in a clean, backwards compatible manner,
  9. * they are implemented as files in a "private" directory.
  10. * Each EA is in it's own file, with the directory layout like so (/ is assumed
  11. * to be relative to fs root). Inside the /.reiserfs_priv/xattrs directory,
  12. * directories named using the capital-hex form of the objectid and
  13. * generation number are used. Inside each directory are individual files
  14. * named with the name of the extended attribute.
  15. *
  16. * So, for objectid 12648430, we could have:
  17. * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_access
  18. * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_default
  19. * /.reiserfs_priv/xattrs/C0FFEE.0/user.Content-Type
  20. * .. or similar.
  21. *
  22. * The file contents are the text of the EA. The size is known based on the
  23. * stat data describing the file.
  24. *
  25. * In the case of system.posix_acl_access and system.posix_acl_default, since
  26. * these are special cases for filesystem ACLs, they are interpreted by the
  27. * kernel, in addition, they are negatively and positively cached and attached
  28. * to the inode so that unnecessary lookups are avoided.
  29. *
  30. * Locking works like so:
  31. * Directory components (xattr root, xattr dir) are protectd by their i_mutex.
  32. * The xattrs themselves are protected by the xattr_sem.
  33. */
  34. #include <linux/reiserfs_fs.h>
  35. #include <linux/capability.h>
  36. #include <linux/dcache.h>
  37. #include <linux/namei.h>
  38. #include <linux/errno.h>
  39. #include <linux/fs.h>
  40. #include <linux/file.h>
  41. #include <linux/pagemap.h>
  42. #include <linux/xattr.h>
  43. #include <linux/reiserfs_xattr.h>
  44. #include <linux/reiserfs_acl.h>
  45. #include <asm/uaccess.h>
  46. #include <net/checksum.h>
  47. #include <linux/stat.h>
  48. #include <linux/quotaops.h>
  49. #include <linux/security.h>
  50. #define PRIVROOT_NAME ".reiserfs_priv"
  51. #define XAROOT_NAME "xattrs"
  52. /* Helpers for inode ops. We do this so that we don't have all the VFS
  53. * overhead and also for proper i_mutex annotation.
  54. * dir->i_mutex must be held for all of them. */
  55. #ifdef CONFIG_REISERFS_FS_XATTR
  56. static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
  57. {
  58. BUG_ON(!mutex_is_locked(&dir->i_mutex));
  59. return dir->i_op->create(dir, dentry, mode, NULL);
  60. }
  61. #endif
  62. static int xattr_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  63. {
  64. BUG_ON(!mutex_is_locked(&dir->i_mutex));
  65. return dir->i_op->mkdir(dir, dentry, mode);
  66. }
  67. /* We use I_MUTEX_CHILD here to silence lockdep. It's safe because xattr
  68. * mutation ops aren't called during rename or splace, which are the
  69. * only other users of I_MUTEX_CHILD. It violates the ordering, but that's
  70. * better than allocating another subclass just for this code. */
  71. static int xattr_unlink(struct inode *dir, struct dentry *dentry)
  72. {
  73. int error;
  74. BUG_ON(!mutex_is_locked(&dir->i_mutex));
  75. reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
  76. I_MUTEX_CHILD, dir->i_sb);
  77. error = dir->i_op->unlink(dir, dentry);
  78. mutex_unlock(&dentry->d_inode->i_mutex);
  79. if (!error)
  80. d_delete(dentry);
  81. return error;
  82. }
  83. static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
  84. {
  85. int error;
  86. BUG_ON(!mutex_is_locked(&dir->i_mutex));
  87. reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
  88. I_MUTEX_CHILD, dir->i_sb);
  89. dentry_unhash(dentry);
  90. error = dir->i_op->rmdir(dir, dentry);
  91. if (!error)
  92. dentry->d_inode->i_flags |= S_DEAD;
  93. mutex_unlock(&dentry->d_inode->i_mutex);
  94. if (!error)
  95. d_delete(dentry);
  96. dput(dentry);
  97. return error;
  98. }
  99. #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE)
  100. static struct dentry *open_xa_root(struct super_block *sb, int flags)
  101. {
  102. struct dentry *privroot = REISERFS_SB(sb)->priv_root;
  103. struct dentry *xaroot;
  104. if (!privroot->d_inode)
  105. return ERR_PTR(-ENODATA);
  106. mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
  107. xaroot = dget(REISERFS_SB(sb)->xattr_root);
  108. if (!xaroot)
  109. xaroot = ERR_PTR(-ENODATA);
  110. else if (!xaroot->d_inode) {
  111. int err = -ENODATA;
  112. if (xattr_may_create(flags))
  113. err = xattr_mkdir(privroot->d_inode, xaroot, 0700);
  114. if (err) {
  115. dput(xaroot);
  116. xaroot = ERR_PTR(err);
  117. }
  118. }
  119. mutex_unlock(&privroot->d_inode->i_mutex);
  120. return xaroot;
  121. }
  122. static struct dentry *open_xa_dir(const struct inode *inode, int flags)
  123. {
  124. struct dentry *xaroot, *xadir;
  125. char namebuf[17];
  126. xaroot = open_xa_root(inode->i_sb, flags);
  127. if (IS_ERR(xaroot))
  128. return xaroot;
  129. snprintf(namebuf, sizeof(namebuf), "%X.%X",
  130. le32_to_cpu(INODE_PKEY(inode)->k_objectid),
  131. inode->i_generation);
  132. mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
  133. xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
  134. if (!IS_ERR(xadir) && !xadir->d_inode) {
  135. int err = -ENODATA;
  136. if (xattr_may_create(flags))
  137. err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
  138. if (err) {
  139. dput(xadir);
  140. xadir = ERR_PTR(err);
  141. }
  142. }
  143. mutex_unlock(&xaroot->d_inode->i_mutex);
  144. dput(xaroot);
  145. return xadir;
  146. }
  147. /* The following are side effects of other operations that aren't explicitly
  148. * modifying extended attributes. This includes operations such as permissions
  149. * or ownership changes, object deletions, etc. */
  150. struct reiserfs_dentry_buf {
  151. struct dentry *xadir;
  152. int count;
  153. struct dentry *dentries[8];
  154. };
  155. static int
  156. fill_with_dentries(void *buf, const char *name, int namelen, loff_t offset,
  157. u64 ino, unsigned int d_type)
  158. {
  159. struct reiserfs_dentry_buf *dbuf = buf;
  160. struct dentry *dentry;
  161. WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
  162. if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
  163. return -ENOSPC;
  164. if (name[0] == '.' && (name[1] == '\0' ||
  165. (name[1] == '.' && name[2] == '\0')))
  166. return 0;
  167. dentry = lookup_one_len(name, dbuf->xadir, namelen);
  168. if (IS_ERR(dentry)) {
  169. return PTR_ERR(dentry);
  170. } else if (!dentry->d_inode) {
  171. /* A directory entry exists, but no file? */
  172. reiserfs_error(dentry->d_sb, "xattr-20003",
  173. "Corrupted directory: xattr %s listed but "
  174. "not found for file %s.\n",
  175. dentry->d_name.name, dbuf->xadir->d_name.name);
  176. dput(dentry);
  177. return -EIO;
  178. }
  179. dbuf->dentries[dbuf->count++] = dentry;
  180. return 0;
  181. }
  182. static void
  183. cleanup_dentry_buf(struct reiserfs_dentry_buf *buf)
  184. {
  185. int i;
  186. for (i = 0; i < buf->count; i++)
  187. if (buf->dentries[i])
  188. dput(buf->dentries[i]);
  189. }
  190. static int reiserfs_for_each_xattr(struct inode *inode,
  191. int (*action)(struct dentry *, void *),
  192. void *data)
  193. {
  194. struct dentry *dir;
  195. int i, err = 0;
  196. loff_t pos = 0;
  197. struct reiserfs_dentry_buf buf = {
  198. .count = 0,
  199. };
  200. /* Skip out, an xattr has no xattrs associated with it */
  201. if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1)
  202. return 0;
  203. reiserfs_write_unlock(inode->i_sb);
  204. dir = open_xa_dir(inode, XATTR_REPLACE);
  205. if (IS_ERR(dir)) {
  206. err = PTR_ERR(dir);
  207. reiserfs_write_lock(inode->i_sb);
  208. goto out;
  209. } else if (!dir->d_inode) {
  210. err = 0;
  211. reiserfs_write_lock(inode->i_sb);
  212. goto out_dir;
  213. }
  214. mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
  215. reiserfs_write_lock(inode->i_sb);
  216. buf.xadir = dir;
  217. err = reiserfs_readdir_dentry(dir, &buf, fill_with_dentries, &pos);
  218. while ((err == 0 || err == -ENOSPC) && buf.count) {
  219. err = 0;
  220. for (i = 0; i < buf.count && buf.dentries[i]; i++) {
  221. int lerr = 0;
  222. struct dentry *dentry = buf.dentries[i];
  223. if (err == 0 && !S_ISDIR(dentry->d_inode->i_mode))
  224. lerr = action(dentry, data);
  225. dput(dentry);
  226. buf.dentries[i] = NULL;
  227. err = lerr ?: err;
  228. }
  229. buf.count = 0;
  230. if (!err)
  231. err = reiserfs_readdir_dentry(dir, &buf,
  232. fill_with_dentries, &pos);
  233. }
  234. mutex_unlock(&dir->d_inode->i_mutex);
  235. /* Clean up after a failed readdir */
  236. cleanup_dentry_buf(&buf);
  237. if (!err) {
  238. /* We start a transaction here to avoid a ABBA situation
  239. * between the xattr root's i_mutex and the journal lock.
  240. * This doesn't incur much additional overhead since the
  241. * new transaction will just nest inside the
  242. * outer transaction. */
  243. int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
  244. 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
  245. struct reiserfs_transaction_handle th;
  246. err = journal_begin(&th, inode->i_sb, blocks);
  247. if (!err) {
  248. int jerror;
  249. reiserfs_mutex_lock_nested_safe(
  250. &dir->d_parent->d_inode->i_mutex,
  251. I_MUTEX_XATTR, inode->i_sb);
  252. err = action(dir, data);
  253. jerror = journal_end(&th, inode->i_sb, blocks);
  254. mutex_unlock(&dir->d_parent->d_inode->i_mutex);
  255. err = jerror ?: err;
  256. }
  257. }
  258. out_dir:
  259. dput(dir);
  260. out:
  261. /* -ENODATA isn't an error */
  262. if (err == -ENODATA)
  263. err = 0;
  264. return err;
  265. }
  266. static int delete_one_xattr(struct dentry *dentry, void *data)
  267. {
  268. struct inode *dir = dentry->d_parent->d_inode;
  269. /* This is the xattr dir, handle specially. */
  270. if (S_ISDIR(dentry->d_inode->i_mode))
  271. return xattr_rmdir(dir, dentry);
  272. return xattr_unlink(dir, dentry);
  273. }
  274. static int chown_one_xattr(struct dentry *dentry, void *data)
  275. {
  276. struct iattr *attrs = data;
  277. return reiserfs_setattr(dentry, attrs);
  278. }
  279. /* No i_mutex, but the inode is unconnected. */
  280. int reiserfs_delete_xattrs(struct inode *inode)
  281. {
  282. int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL);
  283. if (err)
  284. reiserfs_warning(inode->i_sb, "jdm-20004",
  285. "Couldn't delete all xattrs (%d)\n", err);
  286. return err;
  287. }
  288. /* inode->i_mutex: down */
  289. int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
  290. {
  291. int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs);
  292. if (err)
  293. reiserfs_warning(inode->i_sb, "jdm-20007",
  294. "Couldn't chown all xattrs (%d)\n", err);
  295. return err;
  296. }
  297. #ifdef CONFIG_REISERFS_FS_XATTR
  298. /* Returns a dentry corresponding to a specific extended attribute file
  299. * for the inode. If flags allow, the file is created. Otherwise, a
  300. * valid or negative dentry, or an error is returned. */
  301. static struct dentry *xattr_lookup(struct inode *inode, const char *name,
  302. int flags)
  303. {
  304. struct dentry *xadir, *xafile;
  305. int err = 0;
  306. xadir = open_xa_dir(inode, flags);
  307. if (IS_ERR(xadir))
  308. return ERR_CAST(xadir);
  309. mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
  310. xafile = lookup_one_len(name, xadir, strlen(name));
  311. if (IS_ERR(xafile)) {
  312. err = PTR_ERR(xafile);
  313. goto out;
  314. }
  315. if (xafile->d_inode && (flags & XATTR_CREATE))
  316. err = -EEXIST;
  317. if (!xafile->d_inode) {
  318. err = -ENODATA;
  319. if (xattr_may_create(flags))
  320. err = xattr_create(xadir->d_inode, xafile,
  321. 0700|S_IFREG);
  322. }
  323. if (err)
  324. dput(xafile);
  325. out:
  326. mutex_unlock(&xadir->d_inode->i_mutex);
  327. dput(xadir);
  328. if (err)
  329. return ERR_PTR(err);
  330. return xafile;
  331. }
  332. /* Internal operations on file data */
  333. static inline void reiserfs_put_page(struct page *page)
  334. {
  335. kunmap(page);
  336. page_cache_release(page);
  337. }
  338. static struct page *reiserfs_get_page(struct inode *dir, size_t n)
  339. {
  340. struct address_space *mapping = dir->i_mapping;
  341. struct page *page;
  342. /* We can deadlock if we try to free dentries,
  343. and an unlink/rmdir has just occured - GFP_NOFS avoids this */
  344. mapping_set_gfp_mask(mapping, GFP_NOFS);
  345. page = read_mapping_page(mapping, n >> PAGE_CACHE_SHIFT, NULL);
  346. if (!IS_ERR(page)) {
  347. kmap(page);
  348. if (PageError(page))
  349. goto fail;
  350. }
  351. return page;
  352. fail:
  353. reiserfs_put_page(page);
  354. return ERR_PTR(-EIO);
  355. }
  356. static inline __u32 xattr_hash(const char *msg, int len)
  357. {
  358. return csum_partial(msg, len, 0);
  359. }
  360. int reiserfs_commit_write(struct file *f, struct page *page,
  361. unsigned from, unsigned to);
  362. int reiserfs_prepare_write(struct file *f, struct page *page,
  363. unsigned from, unsigned to);
  364. static void update_ctime(struct inode *inode)
  365. {
  366. struct timespec now = current_fs_time(inode->i_sb);
  367. if (hlist_unhashed(&inode->i_hash) || !inode->i_nlink ||
  368. timespec_equal(&inode->i_ctime, &now))
  369. return;
  370. inode->i_ctime = CURRENT_TIME_SEC;
  371. mark_inode_dirty(inode);
  372. }
  373. static int lookup_and_delete_xattr(struct inode *inode, const char *name)
  374. {
  375. int err = 0;
  376. struct dentry *dentry, *xadir;
  377. xadir = open_xa_dir(inode, XATTR_REPLACE);
  378. if (IS_ERR(xadir))
  379. return PTR_ERR(xadir);
  380. mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
  381. dentry = lookup_one_len(name, xadir, strlen(name));
  382. if (IS_ERR(dentry)) {
  383. err = PTR_ERR(dentry);
  384. goto out_dput;
  385. }
  386. if (dentry->d_inode) {
  387. reiserfs_write_lock(inode->i_sb);
  388. err = xattr_unlink(xadir->d_inode, dentry);
  389. reiserfs_write_unlock(inode->i_sb);
  390. update_ctime(inode);
  391. }
  392. dput(dentry);
  393. out_dput:
  394. mutex_unlock(&xadir->d_inode->i_mutex);
  395. dput(xadir);
  396. return err;
  397. }
  398. /* Generic extended attribute operations that can be used by xa plugins */
  399. /*
  400. * inode->i_mutex: down
  401. */
  402. int
  403. reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
  404. struct inode *inode, const char *name,
  405. const void *buffer, size_t buffer_size, int flags)
  406. {
  407. int err = 0;
  408. struct dentry *dentry;
  409. struct page *page;
  410. char *data;
  411. size_t file_pos = 0;
  412. size_t buffer_pos = 0;
  413. size_t new_size;
  414. __u32 xahash = 0;
  415. if (get_inode_sd_version(inode) == STAT_DATA_V1)
  416. return -EOPNOTSUPP;
  417. reiserfs_write_unlock(inode->i_sb);
  418. if (!buffer) {
  419. err = lookup_and_delete_xattr(inode, name);
  420. reiserfs_write_lock(inode->i_sb);
  421. return err;
  422. }
  423. dentry = xattr_lookup(inode, name, flags);
  424. if (IS_ERR(dentry)) {
  425. reiserfs_write_lock(inode->i_sb);
  426. return PTR_ERR(dentry);
  427. }
  428. down_write(&REISERFS_I(inode)->i_xattr_sem);
  429. reiserfs_write_lock(inode->i_sb);
  430. xahash = xattr_hash(buffer, buffer_size);
  431. while (buffer_pos < buffer_size || buffer_pos == 0) {
  432. size_t chunk;
  433. size_t skip = 0;
  434. size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1));
  435. if (buffer_size - buffer_pos > PAGE_CACHE_SIZE)
  436. chunk = PAGE_CACHE_SIZE;
  437. else
  438. chunk = buffer_size - buffer_pos;
  439. page = reiserfs_get_page(dentry->d_inode, file_pos);
  440. if (IS_ERR(page)) {
  441. err = PTR_ERR(page);
  442. goto out_unlock;
  443. }
  444. lock_page(page);
  445. data = page_address(page);
  446. if (file_pos == 0) {
  447. struct reiserfs_xattr_header *rxh;
  448. skip = file_pos = sizeof(struct reiserfs_xattr_header);
  449. if (chunk + skip > PAGE_CACHE_SIZE)
  450. chunk = PAGE_CACHE_SIZE - skip;
  451. rxh = (struct reiserfs_xattr_header *)data;
  452. rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
  453. rxh->h_hash = cpu_to_le32(xahash);
  454. }
  455. err = reiserfs_prepare_write(NULL, page, page_offset,
  456. page_offset + chunk + skip);
  457. if (!err) {
  458. if (buffer)
  459. memcpy(data + skip, buffer + buffer_pos, chunk);
  460. err = reiserfs_commit_write(NULL, page, page_offset,
  461. page_offset + chunk +
  462. skip);
  463. }
  464. unlock_page(page);
  465. reiserfs_put_page(page);
  466. buffer_pos += chunk;
  467. file_pos += chunk;
  468. skip = 0;
  469. if (err || buffer_size == 0 || !buffer)
  470. break;
  471. }
  472. new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
  473. if (!err && new_size < i_size_read(dentry->d_inode)) {
  474. struct iattr newattrs = {
  475. .ia_ctime = current_fs_time(inode->i_sb),
  476. .ia_size = buffer_size,
  477. .ia_valid = ATTR_SIZE | ATTR_CTIME,
  478. };
  479. reiserfs_write_unlock(inode->i_sb);
  480. mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
  481. down_write(&dentry->d_inode->i_alloc_sem);
  482. reiserfs_write_lock(inode->i_sb);
  483. err = reiserfs_setattr(dentry, &newattrs);
  484. up_write(&dentry->d_inode->i_alloc_sem);
  485. mutex_unlock(&dentry->d_inode->i_mutex);
  486. } else
  487. update_ctime(inode);
  488. out_unlock:
  489. up_write(&REISERFS_I(inode)->i_xattr_sem);
  490. dput(dentry);
  491. return err;
  492. }
  493. /* We need to start a transaction to maintain lock ordering */
  494. int reiserfs_xattr_set(struct inode *inode, const char *name,
  495. const void *buffer, size_t buffer_size, int flags)
  496. {
  497. struct reiserfs_transaction_handle th;
  498. int error, error2;
  499. size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size);
  500. if (!(flags & XATTR_REPLACE))
  501. jbegin_count += reiserfs_xattr_jcreate_nblocks(inode);
  502. reiserfs_write_lock(inode->i_sb);
  503. error = journal_begin(&th, inode->i_sb, jbegin_count);
  504. if (error) {
  505. reiserfs_write_unlock(inode->i_sb);
  506. return error;
  507. }
  508. error = reiserfs_xattr_set_handle(&th, inode, name,
  509. buffer, buffer_size, flags);
  510. error2 = journal_end(&th, inode->i_sb, jbegin_count);
  511. if (error == 0)
  512. error = error2;
  513. reiserfs_write_unlock(inode->i_sb);
  514. return error;
  515. }
  516. /*
  517. * inode->i_mutex: down
  518. */
  519. int
  520. reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
  521. size_t buffer_size)
  522. {
  523. ssize_t err = 0;
  524. struct dentry *dentry;
  525. size_t isize;
  526. size_t file_pos = 0;
  527. size_t buffer_pos = 0;
  528. struct page *page;
  529. __u32 hash = 0;
  530. if (name == NULL)
  531. return -EINVAL;
  532. /* We can't have xattrs attached to v1 items since they don't have
  533. * generation numbers */
  534. if (get_inode_sd_version(inode) == STAT_DATA_V1)
  535. return -EOPNOTSUPP;
  536. dentry = xattr_lookup(inode, name, XATTR_REPLACE);
  537. if (IS_ERR(dentry)) {
  538. err = PTR_ERR(dentry);
  539. goto out;
  540. }
  541. down_read(&REISERFS_I(inode)->i_xattr_sem);
  542. isize = i_size_read(dentry->d_inode);
  543. /* Just return the size needed */
  544. if (buffer == NULL) {
  545. err = isize - sizeof(struct reiserfs_xattr_header);
  546. goto out_unlock;
  547. }
  548. if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
  549. err = -ERANGE;
  550. goto out_unlock;
  551. }
  552. while (file_pos < isize) {
  553. size_t chunk;
  554. char *data;
  555. size_t skip = 0;
  556. if (isize - file_pos > PAGE_CACHE_SIZE)
  557. chunk = PAGE_CACHE_SIZE;
  558. else
  559. chunk = isize - file_pos;
  560. page = reiserfs_get_page(dentry->d_inode, file_pos);
  561. if (IS_ERR(page)) {
  562. err = PTR_ERR(page);
  563. goto out_unlock;
  564. }
  565. lock_page(page);
  566. data = page_address(page);
  567. if (file_pos == 0) {
  568. struct reiserfs_xattr_header *rxh =
  569. (struct reiserfs_xattr_header *)data;
  570. skip = file_pos = sizeof(struct reiserfs_xattr_header);
  571. chunk -= skip;
  572. /* Magic doesn't match up.. */
  573. if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
  574. unlock_page(page);
  575. reiserfs_put_page(page);
  576. reiserfs_warning(inode->i_sb, "jdm-20001",
  577. "Invalid magic for xattr (%s) "
  578. "associated with %k", name,
  579. INODE_PKEY(inode));
  580. err = -EIO;
  581. goto out_unlock;
  582. }
  583. hash = le32_to_cpu(rxh->h_hash);
  584. }
  585. memcpy(buffer + buffer_pos, data + skip, chunk);
  586. unlock_page(page);
  587. reiserfs_put_page(page);
  588. file_pos += chunk;
  589. buffer_pos += chunk;
  590. skip = 0;
  591. }
  592. err = isize - sizeof(struct reiserfs_xattr_header);
  593. if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
  594. hash) {
  595. reiserfs_warning(inode->i_sb, "jdm-20002",
  596. "Invalid hash for xattr (%s) associated "
  597. "with %k", name, INODE_PKEY(inode));
  598. err = -EIO;
  599. }
  600. out_unlock:
  601. up_read(&REISERFS_I(inode)->i_xattr_sem);
  602. dput(dentry);
  603. out:
  604. return err;
  605. }
  606. /*
  607. * In order to implement different sets of xattr operations for each xattr
  608. * prefix with the generic xattr API, a filesystem should create a
  609. * null-terminated array of struct xattr_handler (one for each prefix) and
  610. * hang a pointer to it off of the s_xattr field of the superblock.
  611. *
  612. * The generic_fooxattr() functions will use this list to dispatch xattr
  613. * operations to the correct xattr_handler.
  614. */
  615. #define for_each_xattr_handler(handlers, handler) \
  616. for ((handler) = *(handlers)++; \
  617. (handler) != NULL; \
  618. (handler) = *(handlers)++)
  619. /* This is the implementation for the xattr plugin infrastructure */
  620. static inline struct xattr_handler *
  621. find_xattr_handler_prefix(struct xattr_handler **handlers,
  622. const char *name)
  623. {
  624. struct xattr_handler *xah;
  625. if (!handlers)
  626. return NULL;
  627. for_each_xattr_handler(handlers, xah) {
  628. if (strncmp(xah->prefix, name, strlen(xah->prefix)) == 0)
  629. break;
  630. }
  631. return xah;
  632. }
  633. /*
  634. * Inode operation getxattr()
  635. */
  636. ssize_t
  637. reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
  638. size_t size)
  639. {
  640. struct xattr_handler *handler;
  641. handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
  642. if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
  643. return -EOPNOTSUPP;
  644. return handler->get(dentry, name, buffer, size, handler->flags);
  645. }
  646. /*
  647. * Inode operation setxattr()
  648. *
  649. * dentry->d_inode->i_mutex down
  650. */
  651. int
  652. reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
  653. size_t size, int flags)
  654. {
  655. struct xattr_handler *handler;
  656. handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
  657. if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
  658. return -EOPNOTSUPP;
  659. return handler->set(dentry, name, value, size, flags, handler->flags);
  660. }
  661. /*
  662. * Inode operation removexattr()
  663. *
  664. * dentry->d_inode->i_mutex down
  665. */
  666. int reiserfs_removexattr(struct dentry *dentry, const char *name)
  667. {
  668. struct xattr_handler *handler;
  669. handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
  670. if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
  671. return -EOPNOTSUPP;
  672. return handler->set(dentry, name, NULL, 0, XATTR_REPLACE, handler->flags);
  673. }
  674. struct listxattr_buf {
  675. size_t size;
  676. size_t pos;
  677. char *buf;
  678. struct dentry *dentry;
  679. };
  680. static int listxattr_filler(void *buf, const char *name, int namelen,
  681. loff_t offset, u64 ino, unsigned int d_type)
  682. {
  683. struct listxattr_buf *b = (struct listxattr_buf *)buf;
  684. size_t size;
  685. if (name[0] != '.' ||
  686. (namelen != 1 && (name[1] != '.' || namelen != 2))) {
  687. struct xattr_handler *handler;
  688. handler = find_xattr_handler_prefix(b->dentry->d_sb->s_xattr,
  689. name);
  690. if (!handler) /* Unsupported xattr name */
  691. return 0;
  692. if (b->buf) {
  693. size = handler->list(b->dentry, b->buf + b->pos,
  694. b->size, name, namelen,
  695. handler->flags);
  696. if (size > b->size)
  697. return -ERANGE;
  698. } else {
  699. size = handler->list(b->dentry, NULL, 0, name,
  700. namelen, handler->flags);
  701. }
  702. b->pos += size;
  703. }
  704. return 0;
  705. }
  706. /*
  707. * Inode operation listxattr()
  708. *
  709. * We totally ignore the generic listxattr here because it would be stupid
  710. * not to. Since the xattrs are organized in a directory, we can just
  711. * readdir to find them.
  712. */
  713. ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
  714. {
  715. struct dentry *dir;
  716. int err = 0;
  717. loff_t pos = 0;
  718. struct listxattr_buf buf = {
  719. .dentry = dentry,
  720. .buf = buffer,
  721. .size = buffer ? size : 0,
  722. };
  723. if (!dentry->d_inode)
  724. return -EINVAL;
  725. if (!dentry->d_sb->s_xattr ||
  726. get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
  727. return -EOPNOTSUPP;
  728. dir = open_xa_dir(dentry->d_inode, XATTR_REPLACE);
  729. if (IS_ERR(dir)) {
  730. err = PTR_ERR(dir);
  731. if (err == -ENODATA)
  732. err = 0; /* Not an error if there aren't any xattrs */
  733. goto out;
  734. }
  735. mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
  736. err = reiserfs_readdir_dentry(dir, &buf, listxattr_filler, &pos);
  737. mutex_unlock(&dir->d_inode->i_mutex);
  738. if (!err)
  739. err = buf.pos;
  740. dput(dir);
  741. out:
  742. return err;
  743. }
  744. static int reiserfs_check_acl(struct inode *inode, int mask)
  745. {
  746. struct posix_acl *acl;
  747. int error = -EAGAIN; /* do regular unix permission checks by default */
  748. acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
  749. if (acl) {
  750. if (!IS_ERR(acl)) {
  751. error = posix_acl_permission(inode, acl, mask);
  752. posix_acl_release(acl);
  753. } else if (PTR_ERR(acl) != -ENODATA)
  754. error = PTR_ERR(acl);
  755. }
  756. return error;
  757. }
  758. static int create_privroot(struct dentry *dentry)
  759. {
  760. int err;
  761. struct inode *inode = dentry->d_parent->d_inode;
  762. WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
  763. err = xattr_mkdir(inode, dentry, 0700);
  764. if (err || !dentry->d_inode) {
  765. reiserfs_warning(dentry->d_sb, "jdm-20006",
  766. "xattrs/ACLs enabled and couldn't "
  767. "find/create .reiserfs_priv. "
  768. "Failing mount.");
  769. return -EOPNOTSUPP;
  770. }
  771. dentry->d_inode->i_flags |= S_PRIVATE;
  772. reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
  773. "storage.\n", PRIVROOT_NAME);
  774. return 0;
  775. }
  776. #else
  777. int __init reiserfs_xattr_register_handlers(void) { return 0; }
  778. void reiserfs_xattr_unregister_handlers(void) {}
  779. static int create_privroot(struct dentry *dentry) { return 0; }
  780. #endif
  781. /* Actual operations that are exported to VFS-land */
  782. struct xattr_handler *reiserfs_xattr_handlers[] = {
  783. #ifdef CONFIG_REISERFS_FS_XATTR
  784. &reiserfs_xattr_user_handler,
  785. &reiserfs_xattr_trusted_handler,
  786. #endif
  787. #ifdef CONFIG_REISERFS_FS_SECURITY
  788. &reiserfs_xattr_security_handler,
  789. #endif
  790. #ifdef CONFIG_REISERFS_FS_POSIX_ACL
  791. &reiserfs_posix_acl_access_handler,
  792. &reiserfs_posix_acl_default_handler,
  793. #endif
  794. NULL
  795. };
  796. static int xattr_mount_check(struct super_block *s)
  797. {
  798. /* We need generation numbers to ensure that the oid mapping is correct
  799. * v3.5 filesystems don't have them. */
  800. if (old_format_only(s)) {
  801. if (reiserfs_xattrs_optional(s)) {
  802. /* Old format filesystem, but optional xattrs have
  803. * been enabled. Error out. */
  804. reiserfs_warning(s, "jdm-2005",
  805. "xattrs/ACLs not supported "
  806. "on pre-v3.6 format filesystems. "
  807. "Failing mount.");
  808. return -EOPNOTSUPP;
  809. }
  810. }
  811. return 0;
  812. }
  813. int reiserfs_permission(struct inode *inode, int mask)
  814. {
  815. /*
  816. * We don't do permission checks on the internal objects.
  817. * Permissions are determined by the "owning" object.
  818. */
  819. if (IS_PRIVATE(inode))
  820. return 0;
  821. #ifdef CONFIG_REISERFS_FS_XATTR
  822. /*
  823. * Stat data v1 doesn't support ACLs.
  824. */
  825. if (get_inode_sd_version(inode) != STAT_DATA_V1)
  826. return generic_permission(inode, mask, reiserfs_check_acl);
  827. #endif
  828. return generic_permission(inode, mask, NULL);
  829. }
  830. /* This will catch lookups from the fs root to .reiserfs_priv */
  831. static int
  832. xattr_lookup_poison(struct dentry *dentry, struct qstr *q1, struct qstr *name)
  833. {
  834. struct dentry *priv_root = REISERFS_SB(dentry->d_sb)->priv_root;
  835. if (container_of(q1, struct dentry, d_name) == priv_root)
  836. return -ENOENT;
  837. if (q1->len == name->len &&
  838. !memcmp(q1->name, name->name, name->len))
  839. return 0;
  840. return 1;
  841. }
  842. static const struct dentry_operations xattr_lookup_poison_ops = {
  843. .d_compare = xattr_lookup_poison,
  844. };
  845. int reiserfs_lookup_privroot(struct super_block *s)
  846. {
  847. struct dentry *dentry;
  848. int err = 0;
  849. /* If we don't have the privroot located yet - go find it */
  850. reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
  851. dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
  852. strlen(PRIVROOT_NAME));
  853. if (!IS_ERR(dentry)) {
  854. REISERFS_SB(s)->priv_root = dentry;
  855. if (!reiserfs_expose_privroot(s))
  856. s->s_root->d_op = &xattr_lookup_poison_ops;
  857. if (dentry->d_inode)
  858. dentry->d_inode->i_flags |= S_PRIVATE;
  859. } else
  860. err = PTR_ERR(dentry);
  861. mutex_unlock(&s->s_root->d_inode->i_mutex);
  862. return err;
  863. }
  864. /* We need to take a copy of the mount flags since things like
  865. * MS_RDONLY don't get set until *after* we're called.
  866. * mount_flags != mount_options */
  867. int reiserfs_xattr_init(struct super_block *s, int mount_flags)
  868. {
  869. int err = 0;
  870. struct dentry *privroot = REISERFS_SB(s)->priv_root;
  871. err = xattr_mount_check(s);
  872. if (err)
  873. goto error;
  874. if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
  875. reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
  876. err = create_privroot(REISERFS_SB(s)->priv_root);
  877. mutex_unlock(&s->s_root->d_inode->i_mutex);
  878. }
  879. if (privroot->d_inode) {
  880. s->s_xattr = reiserfs_xattr_handlers;
  881. reiserfs_mutex_lock_safe(&privroot->d_inode->i_mutex, s);
  882. if (!REISERFS_SB(s)->xattr_root) {
  883. struct dentry *dentry;
  884. dentry = lookup_one_len(XAROOT_NAME, privroot,
  885. strlen(XAROOT_NAME));
  886. if (!IS_ERR(dentry))
  887. REISERFS_SB(s)->xattr_root = dentry;
  888. else
  889. err = PTR_ERR(dentry);
  890. }
  891. mutex_unlock(&privroot->d_inode->i_mutex);
  892. }
  893. error:
  894. if (err) {
  895. clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt));
  896. clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt));
  897. }
  898. /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
  899. if (reiserfs_posixacl(s))
  900. s->s_flags |= MS_POSIXACL;
  901. else
  902. s->s_flags &= ~MS_POSIXACL;
  903. return err;
  904. }